Stat-Arb en Memecoins: Script para Trackear Whales

Buenas, devs y cazadores de profit fácil. Vamos al grano: si creen que las memecoins son pura comunidad genial y fotos de perritos con sombrero, ya pueden ir cerrando la pestaña. El mercado de las memecoins es una arena PvP salvaje. Los depredadores profesionales les limpian la wallet a los normies a escala industrial. La mejor forma de no terminar siendo la liquidez de salida de otro es pegarse a los que mueven el mercado: el Smart Money.

Hoy vamos a ver cómo armar un bot de arbitraje estadístico en Python para surfear esta locura. Aprenderán a trackear las wallets correctas directamente de la blockchain y copiar sus swaps antes de que el token se vaya to the moon y solo quede tierra arrasada.

Anatomía del Smart Money en memecoins: ¿Quiénes son?

En los DEX, el dinero inteligente se divide en tres categorías. Si no entienden esto, su script solo va a quemar el colateral en fees. Bueno, esperen... En Solana o Base las fees son un chiste, pero el slippage igual los va a liquidar.

• Insiders (Devs y sus amigos): Splittean y snipean el token en el bloque cero. Se conocen el contrato de memoria y saben cuándo arranca el marketing. Suelen pasar los fondos por mixers, pero los cazamos igual cuando compran el 5% del supply en la primera transacción.
• Snipers con software custom: Tipos conectados a nodos RPC privados y ultra rápidos que revientan cada pool prometedor que se deployea.
• Ballenas de momentum: Analizan el sentiment en redes y meten de 10 a 20 ETH o 500 SOL al inicio de la curva. Ellos meten las velas verdes gigantes en el chart. Seguir a estos es lo más seguro.

Error fatal nº 1: Intentar copiar bots MEV que hacen sándwich en la mempool de Ethereum. Olvídense de ganarle a sus bundles de Flashbots. El script va a mandar la tx, se va a comer un revert y van a tirar los gwei a la basura. Hace una semana me pasó en Base por olvidarme de buildear un filtro para los routers. Cincuenta dólares quemados en gas.

Cómo trackear a una ballena: Lógica del parser

El plan es simple. Necesitamos scrapear los logs de los DEX principales (como Uniswap v3 en Base o Raydium en Solana) de los últimos dos días. Buscamos wallets que hayan clavado un 5x o 10x mínimo.

Para esto no hacen falta APIs premium de miles de dólares. Con el tier gratuito de QuickNode o Alchemy y entender cómo funcionan los logs de la EVM es suficiente. Cada swap en un DEX dispara un evento Swap. Filtramos esas direcciones, las metemos a una base de datos (con MariaDB alcanza y sobra, no se compliquen con Postgres para logs planos) y calculamos el PnL.

Al principio pensé en armar el parser con inline assembly en Rust para que vuele, pero fue puro hype. Demasiado boilerplate para un MVP. Python con web3.py se lo banca sin transpirar.

Codeando el script: Tracker y ejecutor de swaps

Acá tienen el script funcional para redes EVM (Base, Arbitrum, BSC). Escucha el nodo RPC, filtra las txs de la wallet objetivo y, en cuanto detecta que interactúa con swapExactTokensForTokens o similares, gatilla el mismo buy order al instante.

En L2 no hay mempool. No existe. Todo corre por FCFS (First Come, First Served). El primero que llega se queda con el token. Por eso, la latencia de su nodo lo es todo.

Python

import time
import os
from web3 import Web3
from eth_account import Account
# Configuración básica
RPC_URL = "https://mainnet.base.org"  # Usar nodo privado, los públicos mueren al toque
PRIVATE_KEY = "TU_PRIVATE_KEY_ACA_NO_LA_MUESTRES"
SMART_MONEY_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e" # Wallet de la ballena a seguir
ROUTER_ADDRESS = "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24" # Router de Uniswap v3 en Base
# WETH y token objetivo (el address real se saca del input de la tx de la ballena)
WETH_ADDRESS = "0x4200000000000000000000000000000000000006"
w3 = Web3(Web3.HTTPProvider(RPC_URL))
account = Account.from_key(PRIVATE_KEY)
# ABI mínimo del router para clavar el 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):
    """Mete un market buy directo copiando a la ballena"""
    nonce = w3.eth.get_transaction_count(account.address)
    
    # Build de la tx. Margen de gas alto para evitar reverts si se mueve el pool
    tx = router_contract.functions.swapExactETHForTokens(
        0, # amountOutMin = 0. Sí, slippage al 100%, en memes si filtras mucho no te matchea las órdenes
        [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, # Priority alta para entrar primeros en el bloque
        'maxPriorityFeePerGas': w3.to_wei(2, 'gwei'),
        'nonce': nonce,
        'chainId': 8453 # Base
    })
    
    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? A chequear en el explorer...
def monitor_wallet():
    print("Bot corriendo. Esperando que la ballena mueva fondos...")
    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:
                        # Validar si la tx es de nuestra ballena objetivo
                        if tx['from'].lower() == SMART_MONEY_ADDRESS.lower():
                            print("¡Mierda! La ballena metió una tx.")
                            
                            # Validar interacción con el router
                            if tx['to'] and tx['to'].lower() == ROUTER_ADDRESS.lower():
                                # Acá se parsea el input data para sacar el token real.
                                # Usamos un address hardcodeado de ejemplo:
                                target_meme = "0x1111111111111111111111111111111111111111" 
                                
                                print(f"Copiando trade. Comprando {target_meme}")
                                buy_token(target_meme, 0.01) # Bag de prueba con centavos
                                
                last_block = current_block
            time.sleep(0.5) # Anti-rate limit del RPC
        except Exception as e:
            # Clásico fix de madrugada
            print(f"Rompió algo, relanzando loop: {e}")
            time.sleep(1)
if __name__ == "__main__":
    monitor_wallet()

Riesgos, trampas y cómo van a usar tu script de salida

Mientras su script procesa los datos y calcula el gas, la ballena puede estar haciendo shilling o armando una trampa para sus seguidores. Existe algo llamado Honeypot (trampa de miel).

El exploit es viejo pero efectivo:

1. La ballena (o el dev) deployea un token con una blacklist que impide vender a cualquier wallet que no esté aprobada en el contrato.
2. El mismo dev simula compras falsas para inflar el gráfico ante los ojos de la blockchain.
3. El script detecta el movimiento del "Smart Money", se mete en el mismo bloque y compra.

Felicidades. Acaban de comprar un token basura que es matemáticamente imposible de vender. Sus fondos quedan atrapados en el pool, la ballena retira la liquidez legítima y ustedes se quedan con las manos vacías.

¿Cómo se frena esto? Antes de mandar el buy, el bot tiene que tirar una simulación local de la tx (usando eth_call). Si la simulación de la venta posterior tira un error o un revert, el token se va directo a la blacklist. Si no integran esta lógica de protección en el core del script, van a quemar la wallet en un par de días.

Ya que tocamos el tema de las simulaciones, vamos a desglosar este dolor de cabeza más a fondo. La mayoría de los novatos piensa: "Armo un log parser, entro a mercado en todo y me forro en plata". Ni de coña.
Sin una simulación pre-trade, eres comida gratis para los scammers.

Simulación Pre-Trade: Cómo no comerte un Honeypot

Cuando una ballena entra en un contrato nuevo, tu script no puede clonar la dirección a ciegas. Primero hay que testear si esa shitcoin se puede vender de vuelta. Para esto se usa el método eth_call. Simulamos la llamada de la función swapExactTokensForETH a nivel local en el nodo, sin mandar la transacción a la mainnet.
Si el nodo tira un revert (error), el token va directo a la blacklist, el script pasa de largo y tu capital se queda safe.
Aquí tienes el bloque de código para meter justo antes de la función buy_token. No armé un simulador completo con fork de red porque, aunque usar Hardhat o Anvil es lo ideal, la idea aquí es tirar un script rápido e improvisado.

Python

def check_honeypot(token_address):
    """
    Check de scam del token. Simula compra y venta.
    Si el contrato bloquea el sell, es un honeypot.
    """
    # Usamos el router para testear con una cantidad miserable.
    test_amount_in = w3.to_wei(0.001, 'ether')
    
    try:
        # Simula buy con eth_call
        # Validamos que no rompa a nivel de smart contract
        router_contract.functions.swapExactETHForTokens(
            0,
            [WETH_ADDRESS, token_address],
            account.address,
            int(time.time()) + 60
        ).call({'from': account.address, 'value': test_amount_in})
        
        # Lo suyo sería simular también el SELL.
        # Pero requiere saldo del token o levantar un fork de la red.
        # A las 3 de la mañana, simular el método buy ya sirve.
        # Los honeypots duros suelen petar directo al tocar el router.
        return True
    except Exception as e:
        print(f"ALERT! Token {token_address} falló simulación: {e}. Descartamos basura.")
        return False

Estrategia de salida: Tomar ganancias y asegurar la caja

Comprar es solo la mitad del trabajo. Salir a tiempo en el mercado de memes es el verdadero arte. Las memecoins se mueven por leyes parabólicas. Un pump salvaje, una pequeña meseta y un desplome inmediato a cero en cuanto las ballenas que entraron temprano empiezan a reventar el order book.
Para los take-profit (TP), armé una estrategia de salidas parciales en escalera que va de lujo:

• Nivel de 2x (+100%): El script vende en automático exactamente el 50% de la posición. Listo, recuperas el capital inicial y te quedas jugando gratis. A partir de ahí, la gestión psicológica es cien veces más fácil.
• Nivel de 3x (+200%): Soltamos otro 25% del sobrante de la mochila.
• Trailing Stop: El resto de la posición (moon bag) corre con la tendencia. En cuanto el precio corrija un 20% desde el pico local, el script liquida todo a mercado.

Alpha desde las trincheras: Si entras con una posición gorda, jamás dejes el amountOutMin en cero al vender. Intentar tirar un token de 500 dólares en un pool con solo 2000 dólares de liquidez es regalarle la plata a los MEV bots vía frontrunning. Tu script recibirá migajas por culpa de un slippage brutal. Toca salir por partes con órdenes pequeñas.

¿Dónde buscar direcciones de Smart Money para arrancar?

Un script sin las wallet adecuadas es solo texto muerto. ¿De dónde sacamos las carteras de las ballenas?

• Dextools / Dexscreener: Abres el top de ganancias de las últimas 24 horas. Vas a la pestaña de Top Traders o Transactions. Buscas las wallets que entraron al inicio (bloque 0-100) y salieron en el pico más alto (ATH). Copias esas direcciones.
• DeBank / Arkham: Metes la dirección copiada ahí dentro. Revisas el win rate del trader. Si la wallet tiene más de 100k dólares generados puramente tradeando shitcoins con un capital inicial de 500 dólares, ese es el objetivo. Lo metes en el array SMART_MONEY_ADDRESSES de tu script.

Conclusión para pragmáticos

El arbitraje estadístico y el copy-trading de memes no son una máquina de imprimir billetes. Es una carrera de velocidad pura y un filtro constante de estafas. Mientras tu script dependa de un nodo RPC público, vas a comer polvo. Si quieres una ventaja real, paga un acceso a nodos privados (como Jito en Solana o nodos EVM personalizados que soporten transacciones rápidas), optimiza la lógica de tus checks y lleva un control de riesgo a rajatabla.
Y lo más importante: no metas en shitcoins dinero que no te puedes permitir perder. Mañana el proyecto mete un revert, el dev tira del cable (rug pull) y ningún script te va a salvar la cuenta.