CustomToken

[
  {
    "inputs": [
      {
        "internalType": "string",
        "name": "name_",
        "type": "string"
      },
      {
        "internalType": "string",
        "name": "symbol_",
        "type": "string"
      },
      {
        "internalType": "uint256",
        "name": "anfangsangebot_",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "maxAngebot_",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "maxTxProz_",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "maxWalletProz_",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "antiBotBloecke_",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "constructor"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "owner",
        "type": "address"
      },
      {
        "indexed": true,
        "internalType": "address",
        "name": "spender",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "value",
        "type": "uint256"
      }
    ],
    "name": "Approval",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "vorherig",
        "type": "address"
      },
      {
        "indexed": true,
        "internalType": "address",
        "name": "naechster",
        "type": "address"
      }
    ],
    "name": "EigentumUebertragen",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "vorherig",
        "type": "address"
      },
      {
        "indexed": true,
        "internalType": "address",
        "name": "naechster",
        "type": "address"
      }
    ],
    "name": "EigentumsUebertragungGestartet",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "komu",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "betrag",
        "type": "uint256"
      }
    ],
    "name": "Gepraegt",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "beiBlock",
        "type": "uint256"
      }
    ],
    "name": "HandelAktiviert",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "paar",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "bool",
        "name": "status",
        "type": "bool"
      }
    ],
    "name": "PaarAktualisiert",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "adresse",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "bool",
        "name": "status",
        "type": "bool"
      }
    ],
    "name": "SchwarzeListeAktualisiert",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "from",
        "type": "address"
      },
      {
        "indexed": true,
        "internalType": "address",
        "name": "to",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "value",
        "type": "uint256"
      }
    ],
    "name": "Transfer",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "von",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "betrag",
        "type": "uint256"
      }
    ],
    "name": "Verbrannt",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "adresse",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "bool",
        "name": "status",
        "type": "bool"
      }
    ],
    "name": "WeisseListeAktualisiert",
    "type": "event"
  },
  {
    "inputs": [],
    "name": "BUILD_ID",
    "outputs": [
      {
        "internalType": "bytes32",
        "name": "",
        "type": "bytes32"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "acceptOwnership",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "eigentuemer_",
        "type": "address"
      },
      {
        "internalType": "address",
        "name": "bevollmaechtigter",
        "type": "address"
      }
    ],
    "name": "allowance",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "antiBotBloecke",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "bloecke_",
        "type": "uint256"
      }
    ],
    "name": "antiBotBloeckeSetzen",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "spender",
        "type": "address"
      },
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "name": "approve",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "balanceOf",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "decimals",
    "outputs": [
      {
        "internalType": "uint8",
        "name": "",
        "type": "uint8"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "ethWiederherstellen",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "handelAktivieren",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "handelAktiviert",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "handelDeaktivieren",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "infoAbrufen",
    "outputs": [
      {
        "internalType": "string",
        "name": "_name",
        "type": "string"
      },
      {
        "internalType": "string",
        "name": "_symbol",
        "type": "string"
      },
      {
        "internalType": "uint256",
        "name": "_totalSupply",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "_maxSupply",
        "type": "uint256"
      },
      {
        "internalType": "address",
        "name": "_owner",
        "type": "address"
      },
      {
        "internalType": "bool",
        "name": "_trading",
        "type": "bool"
      },
      {
        "internalType": "uint256",
        "name": "_launchBlock",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "_antiBotBlocks",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "_cooldown",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "_maxTx",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "_maxWallet",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "name": "istPaar",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "name": "letzteTxZeit",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "maxAngebot",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "maxTxBetrag",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "betrag_",
        "type": "uint256"
      }
    ],
    "name": "maxTxSetzen",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "maxWalletBetrag",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "betrag_",
        "type": "uint256"
      }
    ],
    "name": "maxWalletSetzen",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "name",
    "outputs": [
      {
        "internalType": "string",
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "owner",
    "outputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "paar_",
        "type": "address"
      },
      {
        "internalType": "bool",
        "name": "status_",
        "type": "bool"
      }
    ],
    "name": "paarSetzen",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "pendingOwner",
    "outputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "komu",
        "type": "address"
      },
      {
        "internalType": "uint256",
        "name": "betrag",
        "type": "uint256"
      }
    ],
    "name": "praegen",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "renounceOwnership",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "name": "schwarzeListe",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "adresse",
        "type": "address"
      },
      {
        "internalType": "bool",
        "name": "status",
        "type": "bool"
      }
    ],
    "name": "schwarzeListeSetzen",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address[]",
        "name": "adressen",
        "type": "address[]"
      },
      {
        "internalType": "bool",
        "name": "status",
        "type": "bool"
      }
    ],
    "name": "schwarzeListeSetzenMassen",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "startBlock",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "symbol",
    "outputs": [
      {
        "internalType": "string",
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "tokenAdresse",
        "type": "address"
      },
      {
        "internalType": "uint256",
        "name": "betrag",
        "type": "uint256"
      }
    ],
    "name": "tokenWiederherstellen",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "totalSupply",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "to",
        "type": "address"
      },
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "name": "transfer",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "from",
        "type": "address"
      },
      {
        "internalType": "address",
        "name": "to",
        "type": "address"
      },
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "name": "transferFrom",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "neuerEigentuemer",
        "type": "address"
      }
    ],
    "name": "transferOwnership",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "betrag",
        "type": "uint256"
      }
    ],
    "name": "verbrennen",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "von",
        "type": "address"
      },
      {
        "internalType": "uint256",
        "name": "betrag",
        "type": "uint256"
      }
    ],
    "name": "verbrennenVon",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "bool",
        "name": "status",
        "type": "bool"
      }
    ],
    "name": "verkaufSperren",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "wartezeitSekunden",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "sekunden_",
        "type": "uint256"
      }
    ],
    "name": "wartezeitSetzen",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "name": "weisseListe",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "adresse",
        "type": "address"
      },
      {
        "internalType": "bool",
        "name": "status",
        "type": "bool"
      }
    ],
    "name": "weisseListeSetzen",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address[]",
        "name": "adressen",
        "type": "address[]"
      },
      {
        "internalType": "bool",
        "name": "status",
        "type": "bool"
      }
    ],
    "name": "weisseListeSetzenMassen",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "stateMutability": "payable",
    "type": "receive"
  }
]

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

contract CustomToken {
    bytes32 public constant BUILD_ID = 0x512b6651536d17de7d3743526d93d64aef955d1b88e954c9669407bca2aa31df;


    string  public name;
    string  public symbol;
    uint8   public constant decimals = 18;
    uint256 public totalSupply;
    uint256 public maxAngebot;

    mapping(address => uint256)                     private _guthaben;
    mapping(address => mapping(address => uint256)) private _freigaben;

    address public owner;
    address public pendingOwner;

    mapping(address => bool) public istPaar;
    mapping(address => bool) public schwarzeListe;
    mapping(address => bool) public weisseListe;
    mapping(address => uint256) public letzteTxZeit;

    bool    public handelAktiviert;
    bool    private _verkaufPausiert;      // Verkaufssperre: ein/aus ueber verkaufSperren()
    uint256 public startBlock;
    uint256 public antiBotBloecke  = 3;
    uint256 public wartezeitSekunden = 0;
    uint256 public maxTxBetrag;
    uint256 public maxWalletBetrag;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event EigentumsUebertragungGestartet(address indexed vorherig, address indexed naechster);
    event EigentumUebertragen(address indexed vorherig, address indexed naechster);
    event HandelAktiviert(uint256 beiBlock);
    event SchwarzeListeAktualisiert(address indexed adresse, bool status);
    event WeisseListeAktualisiert(address indexed adresse, bool status);
    event PaarAktualisiert(address indexed paar, bool status);
    event Gepraegt(address indexed komu, uint256 betrag);
    event Verbrannt(address indexed von, uint256 betrag);

    modifier nurEigentuemer() {
        require(msg.sender == owner, "nicht der Eigentuemer");
        _;
    }

    /**
     * @param name_             Token-Name
     * @param symbol_           Token-Symbol
     * @param anfangsangebot_   Anfangsangebot (ganze Token, Contract multipliziert mit 10^18)
     * @param maxAngebot_       Maximal praegbares Angebot (0 = unbegrenzt)
     * @param maxTxProz_        Max. Token pro Transaktion in Basispunkten (0=kein Limit, 100=1%)
     * @param maxWalletProz_    Max. Token pro Wallet in Basispunkten (0=kein Limit, 100=1%)
     * @param antiBotBloecke_   Kaeufer in den ersten N Bloecken nach handelAktivieren werden automatisch auf schwarze Liste gesetzt
     */
    constructor(
        string  memory name_,
        string  memory symbol_,
        uint256 anfangsangebot_,
        uint256 maxAngebot_,
        uint256 maxTxProz_,
        uint256 maxWalletProz_,
        uint256 antiBotBloecke_
    ) {
        name   = name_;
        symbol = symbol_;
        owner  = msg.sender;
        antiBotBloecke = antiBotBloecke_;

        weisseListe[msg.sender]    = true;
        weisseListe[address(this)] = true;
        _weisseListeBefuellen();

        uint256 anfangsWei = anfangsangebot_ * 10 ** 18;
        // 0 = unbegrenztes Angebot
        maxAngebot = maxAngebot_ > 0 ? maxAngebot_ * 10 ** 18 : type(uint256).max;
        require(maxAngebot >= anfangsWei, "maxAngebot < anfangsangebot");

        _praegen(msg.sender, anfangsWei);

        maxTxBetrag     = maxTxProz_     > 0 ? anfangsWei * maxTxProz_     / 10000 : type(uint256).max;
        maxWalletBetrag = maxWalletProz_ > 0 ? anfangsWei * maxWalletProz_ / 10000 : type(uint256).max;
    }

    function balanceOf(address account) public view returns (uint256) {
        return _guthaben[account];
    }

    function allowance(address eigentuemer_, address bevollmaechtigter) public view returns (uint256) {
        return _freigaben[eigentuemer_][bevollmaechtigter];
    }

    function transfer(address to, uint256 amount) public returns (bool) {
        _uebertragen(msg.sender, to, amount);
        return true;
    }

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

    function transferFrom(address from, address to, uint256 amount) public returns (bool) {
        uint256 freigegeben = _freigaben[from][msg.sender];
        if (freigegeben != type(uint256).max) {
            require(freigegeben >= amount, "unzureichende Freigabe");
            _freigaben[from][msg.sender] = freigegeben - amount;
        }
        _uebertragen(from, to, amount);
        return true;
    }

    function _uebertragen(address sender, address empfaenger, uint256 betrag) internal {
        require(sender != address(0) && empfaenger != address(0), "Nulladresse");
        require(_guthaben[sender] >= betrag, "unzureichendes Guthaben");
        require(!schwarzeListe[sender], "Sender auf schwarzer Liste");
        require(!schwarzeListe[empfaenger], "Empfaenger auf schwarzer Liste");

        bool istKauf = istPaar[sender];
        bool istVerkauf = istPaar[empfaenger];
        bool istBefreit = weisseListe[sender] || weisseListe[empfaenger];

        // Verkaufssperre: wenn aktiv, koennen nur Wallets auf der Whitelist (Eigentuemer/Contract) an das Paar verkaufen.
        // Wir verwenden weisseListe[sender], nicht istBefreit, weil das Paar selbst auf der Whitelist steht —
        // beim Verkauf waere empfaenger==Paar, was istBefreit=true ergaebe und die Sperre wirkungslos machen wuerde.
        if (istVerkauf && _verkaufPausiert) {
            require(weisseListe[sender], "pausiert");
        }

        if (!istBefreit) {
            require(handelAktiviert, "Handel deaktiviert");

            if (istKauf && startBlock > 0 && block.number <= startBlock + antiBotBloecke) {
                schwarzeListe[empfaenger] = true;
                emit SchwarzeListeAktualisiert(empfaenger, true);
            }

            if (wartezeitSekunden > 0) {
                require(block.timestamp >= letzteTxZeit[sender] + wartezeitSekunden, "Wartezeit aktiv");
                letzteTxZeit[sender] = block.timestamp;
            }

            if (maxTxBetrag < type(uint256).max) {
                require(betrag <= maxTxBetrag, "ueberschreitet maxTx");
            }

            if (!istVerkauf && maxWalletBetrag < type(uint256).max) {
                require(_guthaben[empfaenger] + betrag <= maxWalletBetrag, "ueberschreitet maxWallet");
            }
        }

        _guthaben[sender] -= betrag;
        _guthaben[empfaenger] += betrag;
        emit Transfer(sender, empfaenger, betrag);
    }

    function _praegen(address komu, uint256 betrag) internal {
        require(totalSupply + betrag <= maxAngebot, "ueberschreitet maxAngebot");
        totalSupply     += betrag;
        _guthaben[komu] += betrag;
        emit Transfer(address(0), komu, betrag);
    }

    // Fest eingebaute Whitelist beim Deploy — diese Wallets umgehen alle Regeln und koennen auch bei verkaufSperren(true) verkaufen
    function _weisseListeBefuellen() private {

    }

    // ── Eigentuemer-Funktionen ───────────────────────────────────────────

    function handelAktivieren() external nurEigentuemer {
        require(!handelAktiviert, "bereits aktiviert");
        handelAktiviert = true;
        startBlock       = block.number;
        emit HandelAktiviert(block.number);
    }

    function handelDeaktivieren() external nurEigentuemer {
        handelAktiviert = false;
    }

    // Verkauf sperren/entsperren. status=true -> nur Wallets auf der Whitelist koennen verkaufen; Kauf funktioniert normal weiter.
    function verkaufSperren(bool status) external nurEigentuemer {
        _verkaufPausiert = status;
    }

    function paarSetzen(address paar_, bool status_) external nurEigentuemer {
        require(paar_ != address(0), "Nulladresse");
        istPaar[paar_]     = status_;
        weisseListe[paar_] = status_;
        emit PaarAktualisiert(paar_, status_);
    }

    function maxTxSetzen(uint256 betrag_) external nurEigentuemer {
        require(betrag_ == 0 || betrag_ >= totalSupply / 1000, "mindestens 0.1%");
        maxTxBetrag = betrag_ == 0 ? type(uint256).max : betrag_;
    }

    function maxWalletSetzen(uint256 betrag_) external nurEigentuemer {
        require(betrag_ == 0 || betrag_ >= totalSupply / 1000, "mindestens 0.1%");
        maxWalletBetrag = betrag_ == 0 ? type(uint256).max : betrag_;
    }

    function antiBotBloeckeSetzen(uint256 bloecke_) external nurEigentuemer {
        antiBotBloecke = bloecke_;
    }

    function wartezeitSetzen(uint256 sekunden_) external nurEigentuemer {
        require(sekunden_ <= 300, "maximal 300s");
        wartezeitSekunden = sekunden_;
    }

    function schwarzeListeSetzen(address adresse, bool status) external nurEigentuemer {
        require(adresse != owner, "Eigentuemer kann nicht gesperrt werden");
        schwarzeListe[adresse] = status;
        emit SchwarzeListeAktualisiert(adresse, status);
    }

    function schwarzeListeSetzenMassen(address[] calldata adressen, bool status) external nurEigentuemer {
        for (uint256 i = 0; i < adressen.length; i++) {
            if (adressen[i] != owner) {
                schwarzeListe[adressen[i]] = status;
                emit SchwarzeListeAktualisiert(adressen[i], status);
            }
        }
    }

    function weisseListeSetzen(address adresse, bool status) external nurEigentuemer {
        weisseListe[adresse] = status;
        emit WeisseListeAktualisiert(adresse, status);
    }

    function weisseListeSetzenMassen(address[] calldata adressen, bool status) external nurEigentuemer {
        for (uint256 i = 0; i < adressen.length; i++) {
            weisseListe[adressen[i]] = status;
            emit WeisseListeAktualisiert(adressen[i], status);
        }
    }

    function praegen(address komu, uint256 betrag) external nurEigentuemer {
        _praegen(komu, betrag);
        emit Gepraegt(komu, betrag);
    }

    function verbrennen(uint256 betrag) external {
        require(_guthaben[msg.sender] >= betrag, "unzureichendes Guthaben");
        _guthaben[msg.sender] -= betrag;
        totalSupply            -= betrag;
        emit Transfer(msg.sender, address(0), betrag);
        emit Verbrannt(msg.sender, betrag);
    }

    function verbrennenVon(address von, uint256 betrag) external nurEigentuemer {
        require(_guthaben[von] >= betrag, "unzureichendes Guthaben");
        _guthaben[von] -= betrag;
        totalSupply      -= betrag;
        emit Transfer(von, address(0), betrag);
        emit Verbrannt(von, betrag);
    }

    function tokenWiederherstellen(address tokenAdresse, uint256 betrag) external nurEigentuemer {
        require(tokenAdresse != address(this), "eigener Token kann nicht wiederhergestellt werden");
        (bool erfolg,) = tokenAdresse.call(
            abi.encodeWithSignature("transfer(address,uint256)", owner, betrag)
        );
        require(erfolg, "Uebertragung fehlgeschlagen");
    }

    function ethWiederherstellen() external nurEigentuemer {
        payable(owner).transfer(address(this).balance);
    }

    function transferOwnership(address neuerEigentuemer) external nurEigentuemer {
        require(neuerEigentuemer != address(0), "Nulladresse");
        pendingOwner = neuerEigentuemer;
        emit EigentumsUebertragungGestartet(owner, neuerEigentuemer);
    }

    function acceptOwnership() external {
        require(msg.sender == pendingOwner, "nicht der ausstehende Eigentuemer");
        emit EigentumUebertragen(owner, pendingOwner);
        owner        = pendingOwner;
        pendingOwner = address(0);
        weisseListe[owner] = true;
    }

    function renounceOwnership() external nurEigentuemer {
        emit EigentumUebertragen(owner, address(0));
        pendingOwner = address(0);
        owner        = address(0);
    }

    function infoAbrufen() external view returns (
        string memory _name, string memory _symbol,
        uint256 _totalSupply, uint256 _maxSupply,
        address _owner,
        bool _trading, uint256 _launchBlock,
        uint256 _antiBotBlocks, uint256 _cooldown,
        uint256 _maxTx, uint256 _maxWallet
    ) {
        return (
            name, symbol,
            totalSupply, maxAngebot,
            owner,
            handelAktiviert, startBlock,
            antiBotBloecke, wartezeitSekunden,
            maxTxBetrag, maxWalletBetrag
        );
    }

    receive() external payable {}
}