Stat-Arb em Memecoins: Script para Trackear Whales

Fala, devs e caçadores de lucro fácil. Vamos alinhar uma coisa de cara: se você acha que meme coin é sobre comunidade fofa e foto de cachorro de chapéu, pode fechar a aba. Mercado de meme coin é PvP puro. É uma arena onde predador profissional limpa a liquidez dos sardinhas em escala industrial. A melhor estratégia para não virar o exit liquidity de alguém é colar em quem mexe o ponteiro do mercado: o Smart Money.

Hoje vamos ver como rodar arbitragem estatística nessa loucura usando Python, rastrear as carteiras certas direto na blockchain e copiar as transações deles antes que o token vá para a Lua e deixe só terra arrasada para a massa.

Anatomia do Smart Money em Memes: Quem são os caras?

Nas DEXs, o "dinheiro inteligente" se divide em três categorias. Sem entender isso, seu script só vai torrar sua banca em taxa — ou melhor, em Solana ou Base a taxa é de centavos, mas você vai ser jantado no slippage de qualquer forma.

• Insiders (Devs e parças): Snipam o token no segundo zero após o deploy. Eles conhecem o código do contrato e sabem o timing do marketing. Geralmente usam mixers para dispersar as carteiras, mas a gente pega o rastro pelo padrão de "primeira transação comprando 5% do supply".
• Snipers com bot proprietário: Caras conectados em RPC nodes privados de altíssima velocidade que engolem qualquer pool promissor.
• Baleias de momento: Analisam o sentimento social e injetam de 10 a 20 ETH ou 500 SOL no early game, printando aquelas velas verdes gigantes no order book. Seguir esses caras é o caminho mais seguro.

Erro fatal #1: Tentar copiar MEV bot que faz sandwich attack no mempool da Ethereum. Você nunca vai bater os bundles do Flashbots deles. Seu script só vai disparar a transação, tomar revert e queimar gas. No outro dia tomei um revert desses na Base porque esqueci de filtrar os router contracts. Menos 50 dólares jogados no lixo.

Como caçar uma baleia: A lógica do parser

O plano é simples. Precisamos minerar os logs de eventos das DEXs (tipo Uniswap v3 na Base ou Raydium na Solana) dos últimos dias. O alvo são carteiras que faturaram pelo menos de 5x a 10x em meme coins.

Não precisa pagar milhares de dólares em APIs corporativas. O plano gratuito da QuickNode ou Alchemy resolve, desde que você entenda como funcionam os logs na blockchain. Cada swap na DEX dispara um evento de Swap. Coletamos esses endereços, jogamos no banco (MariaDB resolve bem, sem necessidade de inflar a stack com Postgres para log simples) e calculamos o PnL.

De início pensei em buildar esse parser usando inline assembler em Rust para voar. Mas desisti. Muito overhead para um MVP. Python com a lib web3.py dá conta do recado sem engasgar.

Buildando o script: Tracker e Auto-buyer

Aqui está o script pronto para redes EVM (Base, Arbitrum, BSC). Ele escuta o RPC node, filtra as transações da carteira alvo e, assim que o cara chama a função swapExactTokensForTokens ou similar, envia uma ordem de compra idêntica no mesmo instante.

Em L2 não existe mempool. Tudo roda na lógica FCFS (First Come, First Served). Quem chegar primeiro leva. Por isso, a latência do seu node define seu sucesso.

Python

import time
import os
from web3 import Web3
from eth_account import Account
# Configs básicas do bot
RPC_URL = "https://mainnet.base.org"  # Use node privado, node público vai de ralo em um minuto
PRIVATE_KEY = "SUA_CHAVE_PRIVADA_AQUI"
SMART_MONEY_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e" # Carteira da baleia alvo
ROUTER_ADDRESS = "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24" # Router da Uniswap v3 na Base
# WETH e token alvo (o endereço correto será extraído da tx da baleia)
WETH_ADDRESS = "0x4200000000000000000000000000000000000006"
w3 = Web3(Web3.HTTPProvider(RPC_URL))
account = Account.from_key(PRIVATE_KEY)
# ABI enxuta do router só para assinar o 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):
    """Executa a compra a mercado espelhando a baleia"""
    nonce = w3.eth.get_transaction_count(account.address)
    
    # Monta a tx. Gas alto para evitar reverter por variação no book
    tx = router_contract.functions.swapExactETHForTokens(
        0, # amountOutMin = 0. Slippage em 100% porque em meme coin se não for assim a tx não passa
        [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, # Força o dobro do gas médio para entrar na frente
        '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)) # Lucro na conta? Checar no explorer...
def monitor_wallet():
    print("Bot rodando. Monitorando os passos da baleia...")
    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:
                        # Valida se a transação partiu da baleia monitorada
                        if tx['from'].lower() == SMART_MONEY_ADDRESS.lower():
                            print("Alerta: Baleia movimentando fundos!")
                            
                            # Valida se a interação foi com o contrato do router
                            if tx['to'] and tx['to'].lower() == ROUTER_ADDRESS.lower():
                                # Em ambiente real aqui tratamos o input data para extrair o token.
                                # Usando um endereço genérico de shitcoin para fins de teste:
                                target_meme = "0x1111111111111111111111111111111111111111" 
                                
                                print(f"Copiando operação. Comprando {target_meme}")
                                buy_token(target_meme, 0.01) # Mão baixa para testar
                                
                last_block = current_block
            time.sleep(0.5) # Evita rate limit no node
        except Exception as e:
            # Dev dorme, mas bug em produção na madrugada não
            print(f"Instabilidade detectada, reiniciando loop: {e}")
            time.sleep(1)
if __name__ == "__main__":
    monitor_wallet()

Riscos, armadilhas e como vão tentar sugar sua liquidez

Enquanto seu script calcula rotas e valida saldos, a baleia pode estar simplesmente despejando nos próprios seguidores que copiam as transações de forma manual ou automatizada. Tem muito golpe estruturado em cima de Honeypots.

A dinâmica é manjada:

1. A baleia (ou o próprio criador do token) faz o deploy de um contrato com código modificado que bloqueia a função de venda para carteiras comuns.
2. O criador executa ordens de compra falsas usando carteiras próprias para gerar rastro na blockchain.
3. Seu script identifica a atividade do "Smart Money", joga a transação no bloco seguinte e executa a compra.

Pronto. Você acabou de comprar um token que não tem permissão para ser vendido de volta para a pool. Seu capital fica preso na blockchain, o criador drena a liquidez e você fica no prejuízo.

Como mitigar isso? Antes de bater a compra, o bot precisa rodar uma simulação da transação (usando chamadas como eth_call). Se a simulação da rota de venda (sell) retornar falha ou revert, o token entra em blacklist imediatamente. Sem essa validação na arquitetura do script, sua banca zera em poucos dias.

Já que toquei no assunto de simulação, vamos destrinchar essa dor de cabeça mais a fundo. A maioria dos iniciantes pensa: "Vou buildar um log parser aqui, entrar a mercado em tudo e encher o carrinho de lucro." Nem fudendo.
Sem simulação pre-trade, você é só liquidez de saída grátis para os scammers.

Simulação Pre-Trade: Como não cair em Honeypot

Quando uma baleia entra num contrato novo, seu script não pode copiar o endereço às cegas. É preciso testar se dá para vender essa shitcoin de volta. Para isso, a gente usa o método eth_call. Simulamos a chamada da função swapExactTokensForETH direto no nó local, sem expor a transação na mainnet.
Se o nó retornar um revert (erro), o token vai direto para a blacklist, o script dropa a operação e seu capital fica safe.
Aqui está o bloco de código para injetar logo antes da função buy_token. Não montei um simulador completo com fork da rede porque, embora rodar via Hardhat ou Anvil seja o jeito ideal, a ideia aqui é codar um script rápido de linha de comando.

Python

def check_honeypot(token_address):
   """
   Scaneia se o token é cilada. Simula compra e venda.
   Se o contrato bloquear o sell, é scam.
   """
   # Usa o router para testar. Bota uma mixaria de volume.
   test_amount_in = w3.to_wei(0.001, 'ether')
   
   try:
       # Simula o buy via eth_call
       # Só valida se não vai estourar erro no nível do contrato
       router_contract.functions.swapExactETHForTokens(
           0,
           [WETH_ADDRESS, token_address],
           account.address,
           int(time.time()) + 60
       ).call({'from': account.address, 'value': test_amount_in})
       
       # O certo seria simular o SELL também.
       # Mas para isso precisa ter saldo do token ou puxar um fork da rede.
       # Às 3 da madruga, só simular o método de buy já quebra o galho.
       # A maioria dos honeypots pesados já crasha direto na chamada do router.
       return True
   except Exception as e:
       print(f"ALERT! Token {token_address} falhou na simulação: {e}. Dropa esse lixo.")
       return False

Estratégia de Saída: Realizando o Lucro e Jogando no Bolso

Comprar é só metade do trampo. Saber a hora de sair nesse mercado de meme é que é a verdadeira arte. Memecoins vivem sob as leis do gráfico parabólico. É um pump violento, um breve platô e o despejo imediato para o zero quando as baleias que entraram cedo começam a despejar no book.
Eu montei uma estratégia de saídas parciais (TP) semi-automatizada em escada. É tiro e queda:

• Gatilho de 2x (+100%): O script vende exatamente 50% da posição de forma automática. Pronto, você tirou o risco da mesa e recuperou o capital inicial. Agora você está no lucro livre. Daí para frente, o psicológico para operar fica cem vezes mais leve.
• Gatilho de 3x (+200%): Despeja mais 25% do restante da mala.
• Trailing Stop: O resto da mão (moon bag) surfa a tendência. Assim que o preço corrigir 20% a partir do topo local, o script stopa tudo a mercado.

Visão de quem tá no front (Alpha): Se a sua mão for pesada, nunca deixe o amountOutMin zerado na hora da venda. Tentar despejar 500 dólares de token num pool que só tem 2000 dólares de liquidez é pedir para ser jantado por MEV bots via frontrunning. Seu script vai receber migalhas por causa do slippage absurdo. Tem que desovar aos poucos, fracionando em ordens menores.

Onde garimpar endereços de Smart Money para começar?

Script sem os alvos certos é só um monte de linha inútil. Onde achar as wallets das baleias?

• Dextools / Dexscreener: Abre a lista dos maiores pumps das últimas 24 horas. Vai na aba de Top Traders ou Transactions. Procura os caras que sniperaram no começo (bloco 0-100) e realizaram no topo. Copia a chave pública deles.
• DeBank / Arkham: Joga o endereço copiado lá dentro. Analisa o win rate do trader. Se o cara tem mais de 100k dólares de saldo na carteira fazendo grana puramente com shitcoin partindo de um aporte inicial de 500 dólares, achamos o nosso alvo. Adiciona ele na array SMART_MONEY_ADDRESSES do seu script.

Papo Reto para Pragmáticos

Arbitragem estatística e copy-trading de memecoins não funcionam como uma impressora de dinheiro infinita. O jogo se resume a uma corrida de velocidade constante e filtragem de golpes. Enquanto seu script rodar em cima de um nó RPC público, você vai comer poeira. Se quer uma vantagem real de mercado, assine um acesso a nós privados (tipo Jito para Solana ou nós EVM customizados com suporte a transações rápidas), otimize suas validações e faça um gerenciamento de risco cirúrgico.
E o mais importante: nunca aloque em shitcoin o dinheiro que você não pode perder. Amanhã o projeto ativa um revert, o dev puxa o tapete (rug pull) e script nenhum no mundo salva seu saldo.