// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import { SafeMath } from './libs/SafeMath.sol';
import { ERC20 } from './libs/ERC20.sol';

import { IUniswapV2Router02 } from './interfaces/IUniswapV2Router02.sol';
import { IUniswapV2Factory } from './interfaces/IUniswapV2Factory.sol';
import { IERC20 } from './interfaces/IERC20.sol';

contract COINBOT is ERC20 {
  using SafeMath for uint256;

  bool private swapping;
  IUniswapV2Router02 public immutable uniswapV2Router;
  address public immutable uniswapV2Pair;

  address public revShareAddress;
  address public teamAddress;

  uint256 public maxTransactionAmount;
  uint256 public swapTokensAtAmount;
  uint256 public maxWallet;

  bool public limitsInEffect = true;
  bool public tradingActive = false;
  bool public swapBackEnabled = false;

  bool public banCapabilityRenounced = false;
  mapping(address => bool) banned;

  uint256 public tradingTotalFees;
  uint256 public tradingRevShareFee;
  uint256 public tradingLiquidityFee;
  uint256 public tradingTeamFee;

  uint256 public tokensForRevShare;
  uint256 public tokensForLiquidity;
  uint256 public tokensForTeam;

  // exclude from fees and max transaction amount
  mapping(address => bool) private _isExcludedFromFees;
  mapping(address => bool) public _isExcludedMaxTransactionAmount;

  // store addresses that a automatic market maker pairs. Any transfer *to* these addresses
  // could be subject to a maximum transfer amount
  mapping(address => bool) public aMMPairs;

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

  event revShareAddressUpdated(address indexed newAddress, address indexed oldAddress);

  event teamAddressUpdated(address indexed newAddress, address indexed oldAddress);

  event SwapToLP(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);

  constructor(address uniswapRouter) ERC20('CoinBot', 'COINBT') {
    IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(uniswapRouter);

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

    uint256 _tradingRevShareFee = 0;
    uint256 _tradingLiquidityFee = 1;
    uint256 _tradingTeamFee = 4;

    uint256 totalSupply = 1_000_000 * 1e18;

    maxTransactionAmount = 10_000 * 1e18; // 1%
    maxWallet = 50_000 * 1e18; // 5%
    swapTokensAtAmount = (totalSupply * 5) / 10000; // 0.05%

    tradingRevShareFee = _tradingRevShareFee;
    tradingLiquidityFee = _tradingLiquidityFee;
    tradingTeamFee = _tradingTeamFee;
    tradingTotalFees = tradingRevShareFee + tradingLiquidityFee + tradingTeamFee;

    revShareAddress = address(0x0185c185007a3099480a3D929944a805141C67CA);
    teamAddress = owner(); // set as team wallet

    _isExcludedMaxTransactionAmount[uniswapRouter] = true;
    _isExcludedMaxTransactionAmount[uniswapV2Pair] = true;
    _setAMMPair(address(uniswapV2Pair), true);
    _excludeFromRules(owner());
    _excludeFromRules(address(this));
    _excludeFromRules(address(0xdead));

    // _mint is an internal function in ERC20.sol that is only called here, once.
    _mint(msg.sender, totalSupply);
  }

  receive() external payable {}

  // once enabled, can never be turned off
  function enableTrading() external onlyOwner {
    tradingActive = true;
    swapBackEnabled = true;
  }

  // remove limits after token is stable
  function removeLimits() external onlyOwner returns (bool) {
    limitsInEffect = false;
    return true;
  }

  // target amount to trigger swap back
  function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool) {
    require(
      newAmount >= (totalSupply() * 1) / 100000,
      'Swap amount cannot be lower than 0.001% total supply.'
    );

    require(
      newAmount <= (totalSupply() * 5) / 1000,
      'Swap amount cannot be higher than 0.5% total supply.'
    );

    swapTokensAtAmount = newAmount;
    return true;
  }

  function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
    require(
      newNum >= ((totalSupply() * 5) / 1000) / 1e18,
      'Cannot set maxTransactionAmount lower than 0.5%'
    );
    maxTransactionAmount = newNum * (10 ** 18);
  }

  function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
    require(newNum >= ((totalSupply() * 10) / 1000) / 1e18, 'Cannot set maxWallet lower than 1.0%');
    maxWallet = newNum * (10 ** 18);
  }
  
  // devs are initially excluded from fees
  // once we are ready to remove limits, we should have the vault created first
  // then we can turn off the limits and renounce the privilege granting capability
  function excludeFromFees(address _address, bool value) external onlyOwner {
    require(limitsInEffect, 'Cannot grant privileges after limits have been removed.');
    _isExcludedFromFees[_address] = value;
  }

  // should only be used to add a staking vault, before limits are removed
  function excludeFromRules(address _address) external onlyOwner {
    require(limitsInEffect, 'Cannot grant privileges after limits have been removed.');
    _excludeFromRules(_address);
  }

  // called in relevant methods, including constructor
  function _excludeFromRules(address _address) internal {
    _isExcludedFromFees[_address] = true;
    _isExcludedMaxTransactionAmount[_address] = true;
  }

  function updateTradingFees(
    uint256 _revShareFee,
    uint256 _liquidityFee,
    uint256 _teamFee
  ) external onlyOwner {
    tradingRevShareFee = _revShareFee;
    tradingLiquidityFee = _liquidityFee;
    tradingTeamFee = _teamFee;
    tradingTotalFees = tradingRevShareFee + tradingLiquidityFee + tradingTeamFee;

    require(tradingTeamFee <= tradingRevShareFee, 'teamFee cannot be greater than revShareFee.');
    require(tradingTotalFees <= 5, 'Buy fees must be <= 5.');
  }

  function setAMMPair(address pair, bool value) external onlyOwner {
    require(pair != uniswapV2Pair, 'The pair cannot be removed from aMMPairs');
    _setAMMPair(pair, value);
  }

  function _setAMMPair(address pair, bool value) private {
    aMMPairs[pair] = value;
    _isExcludedMaxTransactionAmount[pair] = value;
    emit SetAMMPair(pair, value);
  }

  function updateRevShareAddress(address newRevShareAddress) external onlyOwner {
    emit revShareAddressUpdated(newRevShareAddress, revShareAddress);
    _excludeFromRules(newRevShareAddress);
    revShareAddress = newRevShareAddress;
  }

  function updateTeamAddress(address newAddress) external onlyOwner {
    emit teamAddressUpdated(newAddress, teamAddress);
    _excludeFromRules(newAddress);
    teamAddress = newAddress;
  }

  function _transfer(address from, address to, uint256 amount) internal override {
    require(from != address(0), 'ERC20: transfer from the zero address');
    require(to != address(0), 'ERC20: transfer to the zero address');
    require(!banned[from], 'Sender banned');
    require(!banned[to], 'Receiver banned');

    if (amount == 0) {
      super._transfer(from, to, 0);
      return;
    }

    if (limitsInEffect) {
      if (
        from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !swapping
      ) {
        if (!tradingActive) {
          require(_isExcludedFromFees[from] || _isExcludedFromFees[to], 'Trading is not active.');
        }

        // when buy
        if (aMMPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
          require(
            amount <= maxTransactionAmount,
            'Buy transfer amount exceeds the maxTransactionAmount.'
          );
          require(amount + balanceOf(to) <= maxWallet, 'Max wallet exceeded');
        }
        // when sell
        else if (aMMPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
          require(
            amount <= maxTransactionAmount,
            'Sell transfer amount exceeds the maxTransactionAmount.'
          );
        } else if (!_isExcludedMaxTransactionAmount[to]) {
          require(amount + balanceOf(to) <= maxWallet, 'Max wallet exceeded');
        }
      }
    }

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

    if (
      canSwap &&
      swapBackEnabled &&
      !swapping &&
      !aMMPairs[from] &&
      !_isExcludedFromFees[from] &&
      !_isExcludedFromFees[to]
    ) {
      swapping = true;

      swapBack();

      swapping = false;
    }

    bool takeFee = !swapping;

    // if any account belongs to _isExcludedFromFee account then remove the fee
    if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
      takeFee = false;
    }

    uint256 fees = 0;
    // only take fees on trading, do not take on wallet transfers
    if (takeFee) {
      // trading fees
      if ((aMMPairs[to] || aMMPairs[from]) && tradingTotalFees > 0) {
        fees = amount.mul(tradingTotalFees).div(100);
        tokensForLiquidity += (fees * tradingLiquidityFee) / tradingTotalFees;
        tokensForTeam += (fees * tradingTeamFee) / tradingTotalFees;
        tokensForRevShare += (fees * tradingRevShareFee) / tradingTotalFees;
      }

      if (fees > 0) {
        super._transfer(from, address(this), fees);
      }

      amount -= fees;
    }

    super._transfer(from, to, amount);
  }

  function swapTokensForEth(uint256 tokenAmount) private {
    // generate the uniswap pair path of token -> weth
    address[] memory path = new address[](2);
    path[0] = address(this);
    path[1] = uniswapV2Router.WETH();

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

    // make the swap
    uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
      tokenAmount,
      0, // safe because the token swap fees make most MEV unprofitable
      path,
      address(this),
      block.timestamp
    );
  }

  function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
    // approve token transfer to cover all possible scenarios
    _approve(address(this), address(uniswapV2Router), tokenAmount);

    // add the liquidity
    uniswapV2Router.addLiquidityETH{ value: ethAmount }(
      address(this),
      tokenAmount,
      0, // slippage is unavoidable
      0, // slippage is unavoidable
      owner(),
      block.timestamp
    );
  }

  function swapBack() private {
    uint256 contractBalance = balanceOf(address(this));
    uint256 totalTokensToSwap = tokensForLiquidity + tokensForRevShare + tokensForTeam;
    bool success;

    if (contractBalance == 0 || totalTokensToSwap == 0) {
      return;
    }

    if (contractBalance > swapTokensAtAmount * 20) {
      contractBalance = swapTokensAtAmount * 20;
    }

    // Halve the amount of liquidity tokens
    uint256 liquidityTokens = (contractBalance * tokensForLiquidity) / totalTokensToSwap / 2;
    uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);

    uint256 initialETHBalance = address(this).balance;

    swapTokensForEth(amountToSwapForETH);

    uint256 ethBalance = address(this).balance.sub(initialETHBalance);

    uint256 ethForRevShare = ethBalance.mul(tokensForRevShare).div(
      totalTokensToSwap - (tokensForLiquidity / 2)
    );

    uint256 ethForTeam = ethBalance.mul(tokensForTeam).div(
      totalTokensToSwap - (tokensForLiquidity / 2)
    );

    uint256 ethForLiquidity = ethBalance - ethForRevShare - ethForTeam;

    tokensForLiquidity = 0;
    tokensForRevShare = 0;
    tokensForTeam = 0;

    (success, ) = address(teamAddress).call{ value: ethForTeam }('');

    if (liquidityTokens > 0 && ethForLiquidity > 0) {
      addLiquidity(liquidityTokens, ethForLiquidity);
      emit SwapToLP(amountToSwapForETH, ethForLiquidity, tokensForLiquidity);
    }

    (success, ) = address(revShareAddress).call{ value: address(this).balance }('');
  }

  // --- emergency withdraw
  function withdrawStuckToken(address _token) external onlyOwner {
    require(_token != address(0), '_token address cannot be 0');
    uint256 _contractBalance = IERC20(_token).balanceOf(address(this));
    IERC20(_token).transfer(teamAddress, _contractBalance);
  }

// --- emergency withdraw
  function withdrawStuckEth() external onlyOwner {
    (bool success, ) = teamAddress.call{ value: address(this).balance }('');
    require(success, 'Failed to withdraw ETH');
  }

  function isBanned(address account) external view returns (bool) {
    return banned[account];
  }

  function renounceBanCapability() external onlyOwner {
    banCapabilityRenounced = true;
  }

  // --- banning methods to prevent abuses and bots
  function ban(address _address) external onlyOwner {
    require(!banCapabilityRenounced, 'Team has revoked ban rights');
    require(
      _address != address(uniswapV2Pair) &&
        _address != address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D), // UniV2 router
      'Cannot ban Uniswap'
    );

    banned[_address] = true;
  }

  function unban(address _addr) external onlyOwner {
    banned[_addr] = false;
  }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

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

  function _msgData() internal view virtual returns (bytes memory) {
    this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
    return msg.data;
  }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import { Ownable } from '../libs/Owners.sol';

import { SafeMath } from '../libs/SafeMath.sol';
import { IERC20 } from '../interfaces/IERC20.sol';

contract ERC20 is Ownable, IERC20 {
  using SafeMath for uint256;

  mapping(address => uint256) private _balances;

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

  uint256 private _totalSupply;

  string private _name;
  string private _symbol;

  constructor(string memory __name, string memory __symbol) {
    _name = __name;
    _symbol = __symbol;
  }

  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 override returns (uint8) {
    return 18;
  }

  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 recipient, uint256 amount) public virtual override returns (bool) {
    _transfer(_msgSender(), recipient, 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) {
    _approve(_msgSender(), spender, amount);
    return true;
  }

  function transferFrom(
    address sender,
    address recipient,
    uint256 amount
  ) public override returns (bool) {
    _transfer(sender, recipient, amount);
    _approve(
      sender,
      _msgSender(),
      _allowances[sender][_msgSender()].sub(amount, 'ERC20: transfer amount exceeds allowance')
    );
    return true;
  }

  function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
    _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
    return true;
  }

  function decreaseAllowance(
    address spender,
    uint256 subtractedValue
  ) public virtual returns (bool) {
    uint256 currentAllowance = _allowances[_msgSender()][spender];
    require(currentAllowance >= subtractedValue, 'ERC20: decreased allowance below zero');
    unchecked {
      _approve(_msgSender(), spender, currentAllowance - subtractedValue);
    }

    return true;
  }

  function _transfer(address sender, address recipient, uint256 amount) internal virtual {
    require(sender != address(0), 'ERC20: transfer from the zero address');
    require(recipient != address(0), 'ERC20: transfer to the zero address');

    _beforeTokenTransfer(sender, recipient, amount);

    uint256 senderBalance = _balances[sender];
    require(senderBalance >= amount, 'ERC20: transfer amount exceeds balance');
    unchecked {
      _balances[sender] = senderBalance - amount;
    }
    _balances[recipient] += amount;

    emit Transfer(sender, recipient, amount);

    _afterTokenTransfer(sender, recipient, amount);
  }

  function _mint(address account, uint256 amount) internal virtual {
    require(account != address(0), 'ERC20: mint to the zero address');

    _beforeTokenTransfer(address(0), account, amount);

    _totalSupply += amount;
    _balances[account] += amount;
    emit Transfer(address(0), account, amount);

    _afterTokenTransfer(address(0), account, amount);
  }

  function _burn(address account, uint256 amount) internal virtual {
    require(account != address(0), 'ERC20: burn from the zero address');

    _beforeTokenTransfer(account, address(0), amount);

    uint256 accountBalance = _balances[account];
    require(accountBalance >= amount, 'ERC20: burn amount exceeds balance');
    unchecked {
      _balances[account] = accountBalance - amount;
    }
    _totalSupply -= amount;

    emit Transfer(account, address(0), amount);

    _afterTokenTransfer(account, address(0), amount);
  }

  function _approve(address owner, address spender, uint256 amount) internal virtual {
    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 _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

  function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

interface IERC20 {
  function decimals() external view returns (uint8);

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

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

interface IUniswapV2Factory {
    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(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

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

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;

    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

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

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);

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

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

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

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

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import { Context } from './Context.sol';

abstract contract Ownable is Context {
  address private _owner;

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

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

  modifier onlyOwner() {
    require(owner() == _msgSender(), '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), 'Ownable: new owner is the zero address');
    _transferOwnership(newOwner);
  }

  function _transferOwnership(address newOwner) internal virtual {
    _owner = newOwner;
  }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

library SafeMath {
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    require(c >= a, 'SafeMath: addition overflow');

    return c;
  }

  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    return sub(a, b, 'SafeMath: subtraction overflow');
  }

  function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b <= a, errorMessage);
    uint256 c = a - b;

    return c;
  }

  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }

    uint256 c = a * b;
    require(c / a == b, 'SafeMath: multiplication overflow');

    return c;
  }

  function div(uint256 a, uint256 b) internal pure returns (uint256) {
    return div(a, b, 'SafeMath: division by zero');
  }

  function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b > 0, errorMessage);
    uint256 c = a / b;
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold

    return c;
  }

  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
    return mod(a, b, 'SafeMath: modulo by zero');
  }

  function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
    require(b != 0, errorMessage);
    return a % b;
  }
}

{
  "compilationTarget": {
    "contracts/COIN.sol": "COINBOT"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 2000
  },
  "remappings": []
}