Memecoin Stat-Arb: Python-Skript zum Whale-Tracking

Moin Devs und Profit-Jäger. Machen wir uns direkt am Anfang ehrlich: Wenn ihr glaubt, dass Memecoins nur aus einer netten Community und Hunden mit Hüten bestehen, macht den Tab direkt zu. Der Memecoin-Markt ist eine reine PvP-Arena. Professionelle Sniper ziehen hier Kleinanleger im industriellen Stil ab. Wer nicht als Exit-Liquidity für die Gewinne anderer enden will, muss sich an die Fersen der Marktstifter heften: Smart Money.

Heute bauen wir mit Python einen statistischen Arbitrage-Bot für diesen Wahnsinn. Wir filtern die fetten Wallets direkt aus der Blockchain und kopieren ihre Trades, bevor der Token Richtung Mond abhebt und für den Rest nur verbrannte Erde übrig bleibt.

Anatomie von Smart Money bei Memecoins: Wer zieht hier die Fäden?

Auf dezentralen Börsen (DEXs) teilt sich das smarte Geld in drei Lager. Ohne dieses Verständnis verbrennt dein Skript die gesamte Margin nur für Fees. Wobei, Moment... Auf Solana oder Base kosten die Gebühren fast nichts. Die Slippage wird dich trotzdem komplett zerlegen.

• Insider (Devs und ihre Kollegen): Snipen den Token in der ersten Sekunde nach dem Deployment. Sie kennen den Contract-Code und den Marketing-Fahrplan. Oft laufen die Wallets über Krypto-Mixer, aber wir catchen sie über das Muster „erste Kauforder zieht direkt 5 % vom Supply“.
• Sniper mit Custom-Software: Leute, die auf schnellen RPC-Nodes hocken und jeden vielversprechenden Pool sofort leersaugen.
• Trend-Wale: Analysieren das Social-Media-Sentiment und ballern früh 10–20 ETH oder 500 SOL in ein Projekt. Das sorgt für fette grüne Kerzen im Orderbuch. Hier mitzureiten ist am sichersten.

Todsünde #1: Der Versuch, MEV-Bots zu kopieren, die Sandwich-Attacken im Ethereum-Mempool fahren. Ihr zieht gegen deren Flashbots-Bundles immer den Kürzeren. Euer Skript sendet die Tx, fängt sich einen Revert und das Geld fürs Gas ist weg. Mir ist das letzte Woche auf Base passiert, weil ich vergessen habe, die Router-Contracts zu filtern. 50 Dollar futsch, einfach so.

So findet man die fetten Wale: Logik des Parsers

Der Plan steht. Wir parsen die Event-Logs dezentraler Börsen (wie Uniswap v3 auf Base oder Raydium auf Solana) der letzten paar Tage. Ziel ist es, Wallets zu isolieren, die mit Memecoins mindestens einen 5x bis 10x hingelegt haben.

Teure API-Abos für tausende Euro braucht man dafür nicht. Der Free-Tier von QuickNode oder Alchemy reicht völlig. Man muss nur verstehen, wie Logs in der Blockchain funktionieren. Jeder DEX-Kauf triggert ein Swap-Event. Wir ziehen diese Adressen, klatschen sie in eine Datenbank (MariaDB reicht komplett, kein Grund für ein Postgres-Overengineering) und checken deren PnL.

Eigentlich wollte ich den Parser erst über Inline-Assembler in Rust hochziehen, damit das Teil maximal fliegt. Habe es dann gelassen. Zu viel Aufwand für ein MVP. Python und die web3.py-Library regeln das ohne Probleme.

Der fertige Code: Tracker und Auto-Buyer

Hier ist das fertige Skript für EVM-Chains (Base, Arbitrum, BSC). Es lauscht auf der RPC-Node und filtert die Transaktionen des Ziel-Wals. Sobald er die Funktion swapExactTokensForTokens oder ähnliches triggert, ballert das Skript sofort eine identische Kauforder raus.

Auf L2-Netzwerken gibt es keinen Mempool. Alles läuft nach dem Prinzip FCFS (First Come, First Served). Wer zuerst kommt, mahlt zuerst. Der Speed deiner Node entscheidet hier über alles.

Python

import time
import os
from web3 import Web3
from eth_account import Account
# Config. Hier eigene Daten eintragen.
RPC_URL = "https://mainnet.base.org"  # Private Node nutzen, Public ist nach einer Minute tot
PRIVATE_KEY = "DEIN_PRIVATE_KEY_HIER_NICHT_LEAKEN"
SMART_MONEY_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e" # Die Ziel-Wallet
ROUTER_ADDRESS = "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24" # Beispiel: Uniswap v3 Router auf Base
# WETH und Ziel-Token (Adresse wird aus der Wal-Tx extrahiert)
WETH_ADDRESS = "0x4200000000000000000000000000000000000006"
w3 = Web3(Web3.HTTPProvider(RPC_URL))
account = Account.from_key(PRIVATE_KEY)
# Minimal-ABI für den Router, reicht für den Swap
ROUTER_ABI = [
    {
        "inputs": [
            {"internalType": "uint256", "name": "amountOutMin", "type": "uint256"},
            {"internalType": "address[]", "name": "path", "type": "address[]"},
            {"internalType": "address", "name": "to", "type": "address"},
            {"internalType": "uint256", "name": "deadline", "type": "uint256"}
        ],
        "name": "swapExactETHForTokens",
        "outputs": [{"internalType": "uint256[]", "name": "amounts", "type": "uint256[]"}],
        "stateMutability": "payable",
        "type": "function"
    }
]
router_contract = w3.eth.contract(address=ROUTER_ADDRESS, abi=ROUTER_ABI)
def buy_token(target_token_address, eth_amount_to_spend):
    """Kauf per Market-Order direkt hinter dem Wal"""
    nonce = w3.eth.get_transaction_count(account.address)
    
    # Tx bauen. Gas großzügig ansetzen, sonst droht Revert bei hoher Volatilität.
    tx = router_contract.functions.swapExactETHForTokens(
        0, # amountOutMin = 0. 100% Slippage. Bei Memecoins kriegt man sonst keine Füllung.
        [WETH_ADDRESS, target_token_address],
        account.address,
        int(time.time()) + 60
    ).build_transaction({
        'from': account.address,
        'value': w3.to_wei(eth_amount_to_spend, 'ether'),
        'gas': 250000,
        'maxFeePerGas': w3.eth.gas_price * 2, # Gas verdoppeln, um die Tx vornanzustellen
        'maxPriorityFeePerGas': w3.to_wei(2, 'gwei'),
        'nonce': nonce,
        'chainId': 8453 # Base Chain ID
    })
    
    signed_tx = w3.eth.account.sign_transaction(tx, private_key=PRIVATE_KEY)
    tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
    print(hex(tx_hash)) # Profit auf die Wallet? Im Explorer checken...
def monitor_wallet():
    print("Skript läuft. Scanne nach Wal-Aktivität...")
    last_block = w3.eth.block_number
    
    while True:
        try:
            current_block = w3.eth.block_number
            if current_block > last_block:
                for block_num in range(last_block + 1, current_block + 1):
                    block = w3.eth.get_block(block_num, full_transactions=True)
                    for tx in block.transactions:
                        # Prüfen, ob Tx vom Wal stammt
                        if tx['from'].lower() == SMART_MONEY_ADDRESS.lower():
                            print("Achtung! Wal schlägt zu!")
                            
                            # Prüfen, ob der Router aufgerufen wurde
                            if tx['to'] and tx['to'].lower() == ROUTER_ADDRESS.lower():
                                # Hier im Realeinsatz Input-Data parsen und Token-Adresse ziehen.
                                # Für die Demo nehmen wir eine Dummy-Adresse:
                                target_meme = "0x1111111111111111111111111111111111111111" 
                                
                                print(f"Kopiere Wal. Kaufe: {target_meme}")
                                buy_token(target_meme, 0.01) # Kleinstbetrag für den Testlauf
                                
                last_block = current_block
            time.sleep(0.5) # Rate-Limit, um Node-Ban zu verhindern
        except Exception as e:
            # Dev pennt, der Bug um 3 Uhr nachts nicht
            print(f"Crash im Loop, Neustart läuft: {e}")
            time.sleep(1)
if __name__ == "__main__":
    monitor_wallet()

Risiken, Fallen und wie man euch als Exit-Liquidity nutzt

Während dein Skript noch die Wallet-Balance validiert, zieht der Wal vielleicht schon das Geld ab und lässt seine Follower mit wertlosen Token zurück. Das nennt sich Honeypot-Falle.

Die Masche läuft immer gleich ab:

1. Der Wal (oder Insider) deployt einen Token. Im Code ist ein Verkaufsverbot für alle Adressen außer den Whitelist-Wallets hinterlegt.
2. Der Wal kauft seine eigenen Token, sichtbar für die ganze Blockchain.
3. Dein Skript sieht den Smart-Money-Trade, springt in denselben Block und kauft.

Glückwunsch. Du hältst jetzt wertlose Token, die sich physisch nicht mehr in den Pool zurückverkaufen lassen. Das Kapital ist dauerhaft gelockt. Der Wal zieht die Liquidität ab, du gehst komplett leer aus.

Wie schützt man sich? Vor dem echten Kauf muss das Skript den Trade simulieren (zum Beispiel via eth_call). Wenn die Verkaufssimulation fehlschlägt oder einen Revert wirft: Token sofort auf die Blacklist setzen. Wer diese Logik weglässt, verbrennt seine Margin in wenigen Tagen.

Da wir gerade von Simulationen sprechen, lass uns dieses leidige Thema mal genauer sezieren. Die meisten Newbies denken: „Ich schreib mir fix einen Log-Parser, geh per Market-Order rein und zieh das dicke Geld raus.“ Vergiß es.
Ohne Pre-Trade-Simulation bist du für Scammer einfach nur ein gefundenes Fressen.

Pre-Trade-Simulation: Wie man nicht in die Honeypot-Falle tappt

Wenn ein Wal in einen neuen Kontrakt einsteigt, darf das Script nicht blind die Adresse kopieren. Erst muss gecheckt werden, ob sich dieser Shitcoin überhaupt wieder verkaufen lässt. Dafür nutzt man die Methode eth_call. Wir simulieren den Aufruf der Funktion swapExactTokensForETH lokal auf der Node, ohne eine Transaktion ins Live-Netzwerk zu jagen.
Gibt die Node einen Revert (Fehler) zurück, landet der Token auf der Blacklist. Das Script bricht ab und das Kapital bleibt unberührt.
Hier ist das Code-Snippet, das direkt vor die Funktion buy_token gehört. Auf einen kompletten Simulator mit Netzwerk-Fork habe ich hier verzichtet. Über Hardhat oder Anvil wäre das zwar der einzig richtige Weg, aber wir basteln hier ja gerade ein schnelles Script auf die Hand.

Python

def check_honeypot(token_address):
    """
    Token-Check auf Scam. Kauf und Verkauf werden simuliert.
    Blockiert der Kontrakt den Verkauf, ist es ein Honeypot.
    """
    # Router-Check mit Minimalbetrag abschicken
    test_amount_in = w3.to_wei(0.001, 'ether')
    
    try:
        # Buy-Simulation via eth_call
        # Nur prüfen, ob auf Kontraktebene ein Fehler fliegt
        router_contract.functions.swapExactETHForTokens(
            0,
            [WETH_ADDRESS, token_address],
            account.address,
            int(time.time()) + 60
        ).call({'from': account.address, 'value': test_amount_in})
        
        # Eigentlich müsste hier auch der SELL simuliert werden.
        # Erfordert aber entweder Token-Guthaben oder einen lokalen Netzwerk-Fork.
        # Um 3 Uhr nachts reicht der reine Buy-Check im Emulator erst mal aus.
        # Die meisten miesen Honeypots krepieren eh direkt beim Router-Aufruf.
        return True
    except Exception as e:
        print(f"WARNUNG! Token {token_address} in Simulation gerissen: {e}. Schrott aussortieren.")
        return False

Exit-Strategie: Gewinne sichern und eintüten

Einkaufen ist nur die halbe Miete. Rechtzeitig auszusteigen, das ist auf dem Meme-Markt die eigentliche Kunst. Meme-Coins folgen einer Parabel. Schneller Pump, Plateau, und sofortiger Drop gegen Null, sobald die frühen Wale ihre Positionen im Orderbuch abladen.
Ich fahre hier eine halbautomatische Ladder-Strategie für Take-Profit (TP). Läuft absolut zuverlässig:

• 2x-Marke (+100%): Das Script verkauft automatisch exakt 50% der Position. Damit ist der Einsatz wieder drin, die restliche Position läuft komplett risikofrei. Das tradet sich psychologisch direkt hundertmal entspannter.
• 3x-Marke (+200%): Die nächsten 25% vom verbleibenden Bag werden abgestoßen.
• Trailing-Stop: Der Rest der Position (Moon-Bag) läuft mit dem Trend. Sobald der Kurs um 20% vom lokalen Peak einbricht, schließt das Script alles per Market-Order.

Alpha-Inside aus den Schützengräben: Bei fetten Positionen niemals amountOutMin beim Verkauf auf Null setzen. Wer versucht, Token im Wert von 500 Dollar in einen Pool mit nur 2000 Dollar Liquidität zu dumpen, wird von MEV-Bots per Frontrunning gnadenlos rasiert. Durch den brutalen Slippage kommen im Script am Ende nur Centbeträge an. Verkauft wird gestaffelt in kleinen Orders.

Wo gibt es Smart-Money-Adressen für den Start?

Ein Script ohne die passenden Zieladressen ist völlig nutzlos. Woher also die Wal-Wallets nehmen?

• Dextools / Dexscreener: Die Top-Gewinner der letzten 24 Stunden öffnen. In den Reiter „Top Traders“ oder „Transactions“ wechseln. Nach Wallet-Adressen filtern, die direkt zum Start (Block 0-100) eingekauft und am Allzeithoch (ATH) verkauft haben. Adressen rauskopieren.
• DeBank / Arkham: Kopierte Adresse dort reinhauen und die Win-Rate des Traders checken. Wenn auf dem Wallet über 100k Dollar liegen, die rein aus 500 Dollar Startkapital mit Shitcoins ertradet wurden, haben wir unseren Kandidaten. Adresse ab in das Array SMART_MONEY_ADDRESSES im Script.

Fazit für Pragmatiker

Statistische Arbitrage und Copy-Trading bei Memes sind keine Gelddruckmaschine. Es ist ein reines Wettrennen um Speed und das Filtern von Scams. Solange das Script über eine öffentliche RPC-Node läuft, hinkst du immer hinterher. Wer echten Alpha-Value will, besorgt sich privaten Node-Zugriff (wie Jito für Solana oder dedizierte EVM-Nodes für Fast-Transactions), optimiert die Prüflogik und betreibt knallhartes Risikomanagement.
Und ganz wichtig: Niemals Geld in Shitcoins ballern, dessen Verlust man nicht verschmerzen kann. Morgen macht ein Projekt den Revert, der Dev zieht die Liquidität (Rug Pull) – und dann rettet dich kein Script der Welt mehr.