Stat-arbitraż na memecoinach: Skrypt do śledzenia wielorybów

Siemanko koderzy i łowcy łatwego zysku. Wyłóżmy kawę na ławę. Jeśli myślicie, że memcoiny to tylko zgrana społeczność i śmieszne pieski w czapkach, to zamknijcie tę kartę. Rynek memów to czysta arena PvP. Zawodowi drapieżnicy masowo golą tu leszczy z ulicy. Najlepszy sposób, żeby nie skończyć jako czyjeś exit liquidity przy realizacji zysków, to podpiąć się pod tych, którzy ruszają tym rynkiem. Czyli pod Smart Money.

Dzisiaj rozbierzemy na czynniki pierwsze statystyczny arbitraż na tym szaleństwie przy użyciu Pythona. Zobaczymy, jak wyciągać odpowiednie portfele bezpośrednio z blockchaina. Nauczymy się też kopiować ich transakcje, zanim token wystrzeli w kosmos i zostawi tłum z niczym.

Anatomia Smart Money na memach: Kim oni są?

Na DEX-ach „mądra kasa” dzieli się na trzy kategorie. Musisz to ogarniać, inaczej twój skrypt po prostu przepali cały depozyt na opłatach sieciowych. Chociaż nie, czekaj. Na Solanie czy Base opłaty to grosze. Ale slippage i tak całkowicie cię zmiecie.

• Insiderzy (Devowie i ich ziomale): Snajpią token w pierwszej sekundzie po wdrożeniu kontraktu. Znają kod od podszewki. Wiedzą, kiedy ruszy marketing. Często czyszczą portfele przez miksery. Łapiemy ich jednak po jednym schemacie: pierwsza transakcja kupuje 5% całego supply.
• Snajperzy z własnym softem: Goście siedzący na szybkich nodach RPC. Błyskawicznie wykupują każdy obiecujący pul.
• Wieloryby grające pod trendy: Analizują sentyment w socialach. Potrafią wlać po 10–20 ETH albo 500 SOL w token na wczesnym etapie, rysując wielkie zielone świece w arkuszu zleceń. Kopiowanie ich ruchów jest najbezpieczniejsze.

Kardynalny błąd nr 1: Próba kopiowania botów MEV, które robią sandwich attacki w mempoolu Ethereum. Nigdy nie wygrasz z ich paczkami Flashbots. Twój skrypt puści transakcję, złapie revert i stracisz kasę na gas. Sam tydzień temu zaliczyłem taki revert na Base. Zapomniałem odfiltrować kontrakty routerów. Pięćdziesiąt baksów poszło w błoto.

Jak wytropić grubasa: Logika parsowania

Plan jest prosty. Musimy przeanalizować logi ze zdecentralizowanych giełd (np. Uniswap v3 na Base albo Raydium na Solanie) z ostatnich kilku dni. Szukamy portfeli, które wykręciły na memach przynajmniej 5-10x.

Nie potrzebujesz płatnych API za tysiące dolarów. Wystarczy darmowy plan na QuickNode lub Alchemy i podstawowa wiedza o logach w blockchainie. Każdy zakup na DEX wywołuje zdarzenie Swap. Wyciągamy te adresy, wrzucamy do bazy (MariaDB w zupełności wystarczy, nie ma co stawiać Postgresa do prostych logów) i liczymy ich PnL.

Na początku chciałem napisać ten parser w Ruście z wstawkami w inline-assemblerze, żeby to dosłownie latało. Potem odpuściłem. Za dużo zachodu jak na MVP. Python z biblioteką web3.py ogarnie temat bez zająknięcia.

Piszesz działający skrypt: Tracker i auto-buyer

Poniżej znajdziesz gotowy skrypt pod sieci EVM (Base, Arbitrum, BSC). Słucha nody RPC i filtruje transakcje konkretnego portfela (naszego wieloryba). Gdy tylko wykryje wywołanie funkcji swapExactTokensForTokens lub podobnej, natychmiast wysyła identyczne zlecenie zakupu.

Pamiętaj, że na L2 nie ma mempoola. W ogóle. Wszystko działa w systemie FCFS (First Come, First Served). Kto pierwszy, ten lepszy. Dlatego prędkość twojej nody decyduje o wszystkim.

Python

import time
import os
from web3 import Web3
from eth_account import Account
# Konfiguracja. Wpisz swoje dane.
RPC_URL = "https://mainnet.base.org"  # bierz prywatną nodę, publiczna padnie po minucie
PRIVATE_KEY = "TWÓJ_KLUCZ_PRYWATNY_NIE_POKAZUJ_NIKOMU"
SMART_MONEY_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e" # adres wieloryba do śledzenia
ROUTER_ADDRESS = "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24" # przykładowy router Uniswap v3 na Base
# WETH i kupowany token (docelowy adres wyciągniemy z tx wieloryba)
WETH_ADDRESS = "0x4200000000000000000000000000000000000006"
w3 = Web3(Web3.HTTPProvider(RPC_URL))
account = Account.from_key(PRIVATE_KEY)
# Minimalne ABI routera, tylko pod 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):
    """Kupujemy marketem zaraz za wielorybem"""
    nonce = w3.eth.get_transaction_count(account.address)
    
    # Budujemy tx. Gas z zapasem, inaczej zrzut, orderbook się ruszy i złapiemy revert
    tx = router_contract.functions.swapExactETHForTokens(
        0, # amountOutMin = 0. Slippage 100%, na memach inaczej nie wejdzie
        [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, # podbijamy gas, żeby wejść jako pierwsi w bloku
        '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)) # Sprawdzamy w explorerze czy weszło...
def monitor_wallet():
    print("Skrypt ruszył. Szukamy gdzie wieloryb ładuje torby...")
    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:
                        # Sprawdzamy nadawcę transakcji
                        if tx['from'].lower() == SMART_MONEY_ADDRESS.lower():
                            print("O kurła, wieloryb ruszył portfelem!")
                            
                            # Sprawdzamy czy to strzał w router
                            if tx['to'] and tx['to'].lower() == ROUTER_ADDRESS.lower():
                                # W realu trzeba sparsować input data i wyciągnąć adres tokena.
                                # Tutaj jako przykład wrzucamy szitcoin-placeholder:
                                target_meme = "0x1111111111111111111111111111111111111111" 
                                
                                print(f"Kopiujemy ruch. Kupuję {target_meme}")
                                buy_token(target_meme, 0.01) # Testowo za grosze
                                
                last_block = current_block
            time.sleep(0.5) # Ochrona przed banem za spam na RPC
        except Exception as e:
            # Klasyka o 3 rano, restart pętli przy błędzie
            print(f"Coś wywaliło, restart pętli: {e}")
            time.sleep(1)
if __name__ == "__main__":
    monitor_wallet()

Ryzyka, pułapki i jak skończysz jako dawca kapitału

Podczas gdy twój skrypt mieli dane i sprawdza stan konta, wieloryb może po prostu doić swoich followersów. Słaba akcja, co? Piszcie w komentarzach, jeśli się mylę. Istnieje jednak mechanizm zwany Honeypotem.

Schemat jest stary jak świat:

1. Wieloryb (albo insider) wypuszcza token. W kodzie blokuje możliwość sprzedaży dla wszystkich poza zaufanymi adresami.
2. Sami od siebie kupują ten token na oczach całego blockchaina.
3. Twój skrypt widzi transakcję „smart money”, wbija w ten sam blok, kupuje...

Gratulacje. Masz w portfelu śmiecia, którego fizycznie nie da się sprzedać z powrotem do puli. Kasa zablokowana na amen. Wieloryb wyciąga płynność, a ty zostajesz z ręką w nocniku.

Jak się przed tym bronić? Przed zakupem skrypt musi odpalić symulację transakcji (np. przez eth_call). Jeśli symulacja sprzedaży (sell) wypluje błąd lub revert, token natychmiast trafia na czarną listę. Jeśli nie dodasz tej weryfikacji bezpośrednio do logiki bota, wyczyszcisz portfel w dwa dni.

Skoro już wspomniałem o symulacjach, przyjrzyjmy się bliżej temu problemowi. Większość świeżaków myśli: „Napiszę parser logów, będę wchodzić po markecie i kosić siano łopatą”. Nic z tego.
Bez symulacji pre-trade jesteś po prostu darmowym obiadem dla scammerów.

Symulacja pre-trade: Jak nie wpaść w Honeypot

Kiedy gruba ryba wchodzi w nowy kontrakt, twój skrypt nie może bezmyślnie kopiować adresu. Trzeba najpierw sprawdzić, czy ten szlam da się w ogóle opchnąć z powrotem. Do tego służy metoda eth_call. Symulujemy wywołanie funkcji swapExactTokensForETH lokalnie na nodzie, bez puszczenia transakcji do mainnetu.
Jeśli noda wyrzuci revert (błąd) – token leci na blacklistę, skrypt odpuszcza, a twój kapitał jest bezpieczny.
Łap kawałek kodu do wklejenia tuż przed funkcją buy_token. Nie stawiałem tutaj pełnego symulatora z forkiem sieci. Wiadomo, że najlepiej zrobić to przez Hardhat/Anvil, ale umówmy się – piszemy szybki skrypt na kolanie.

Python

def check_honeypot(token_address):
    """
    Szybki test na honeypota. Symulujemy buy i sell.
    Jak kontrakt blokuje sprzedaż – to scam.
    """
    # Sprawdzamy przez router. Wrzucamy jakieś grosze.
    test_amount_in = w3.to_wei(0.001, 'ether')
    
    try:
        # Symulacja zakupu przez eth_call
        # Patrzymy tylko, czy nie wywali błędu na poziomie kontraktu
        router_contract.functions.swapExactETHForTokens(
            0,
            [WETH_ADDRESS, token_address],
            account.address,
            int(time.time()) + 60
        ).call({'from': account.address, 'value': test_amount_in})
        
        # Docelowo trzeba by zsymulować też SELL.
        # Ale do tego trzeba mieć już tokeny na balansu albo postawić forka.
        # O 3 nad ranem wystarczy sam check funkcji buy.
        # Większość chamskich honeypotów i tak sypie się już przy pierwszym strzale do routera.
        return True
    except Exception as e:
        print(f"ALERT! Token {token_address} wywalił symulację: {e}. Dropujemy ten syf.")
        return False

Strategia wyjścia: Keszowanie profitu do bazy

Kupić to pikuś. Prawdziwa sztuka na memecoinach to wyjść w odpowiednim momencie. Shitcoiny rosną parabolą. Szybka pompa, konsolidacja na szczycie i natychmiastowy zrzut do zera, kiedy pierwsi insiderzy zaczynają sypać w arkusz.
Sam korzystam z półautomatycznej drabinki do TP. Sprawdza się idealnie:

• Poziom 2x (+100%): Skrypt z automatu wyrzuca dokładnie 50% pozycji. Tym samym odzyskujesz swój wkład i grasz za darmowe żetony. Psychicznie prowadzi się taką pozycję sto razy łatwiej.
• Poziom 3x (+200%): Dumpujemy kolejne 25% z tego, co zostało.
• Trailing stop: Reszta torby (moon bag) jedzie z trendem. Gdy cena spadnie o 20% od lokalnego ATH – skrypt zamyka wszystko po markecie.

Alpha z okopów: Przy grubej pozycji nigdy nie ustawiaj amountOutMin na zero podczas sprzedaży. Jeśli spróbujesz rzucić tokeny warte 500 USD w pulę z płynnością 2000 USD, boty MEV zjedzą cię frontrunniem. Przez gigantyczny slippage skrypt dostanie ochłapy. Trzeba sypać partiami, mniejszymi zleceniami.

Gdzie szukać portfeli Smart Money na start?

Skrypt bez odpowiednich adresów to tylko martwy kod. Skąd brać portfele wielorybów?

• Dextools / Dexscreener: Wchodzisz w top gainerów z ostatnich 24 godzin. Przełączasz na zakładkę Top Traders albo Transactions. Szukasz gości, którzy weszli na samym starcie (blok 0-100) i wyciągnęli profit na górce. Kopiujesz ich adresy.
• DeBank / Arkham: Wklejasz tam skopiowany adres. Sprawdzasz winrate tradera. Jeśli na portfelu ma ponad 100k USD zrobione czysto z 500 USD wkładu na memach – mamy swojego człowieka. Dorzucasz go do tablicy SMART_MONEY_ADDRESSES w kodzie.

Podsumowanie dla pragmatyków

Arbitraż statystyczny i copytrading na memecoinach to nie jest magiczny przycisk „drukuj siano”. To ciągły wyścig technologiczny i odsiewanie syfu. Dopóki twój skrypt wisi na publicznym RPC, zawsze będziesz w ogonie. Jeśli chcesz mieć realny edge, musisz zainwestować w prywatne nody (na przykład Jito dla Solany albo dedykowane nody EVM wspierające szybkie transakcje), dopracować logikę sprawdzania kontraktów i ostro pilnować ryzyka.
I najważniejsze – nie wrzucaj w shitcoiny kasy, której boisz się stracić. Jutro projekt zrobi rewers, dev wyciągnie płynność i żaden skrypt cię przed tym nie uratuje.