Salut les devs et les chasseurs de profit facile. On va mettre les choses au clair tout de suite : si vous pensez encore que les meme coins, c'est juste une histoire de communauté sympa et de photos de chiens avec des chapeaux, vous pouvez fermer cet onglet. Les meme coins, c'est du PvP pur et dur. Une arène où des prédateurs pro s'occupent de raser des meutes de retail à l'échelle industrielle. Le meilleur moyen de ne pas servir de liquidité pour le take profit des autres, c'est de coller au train de ceux qui font bouger le marché : la Smart Money.
Aujourd'hui, on va voir comment faire de l'arbitrage statistique au milieu de ce grand n'importe quoi en utilisant Python. On va capter comment dump les bons wallets directement depuis la blockchain pour copy trade leurs transactions avant que le token ne parte sur la Lune en laissant les miettes au retail.
L'anatomie de la Smart Money sur les memes : C'est qui ces mecs ?
Sur les DEX, l'argent intelligent se divise en trois catégories. Sans cette grille de lecture, votre script va juste cramer votre dépôt en frais de gas. Quoique, attendez... Sur Solana ou Base, le gas ne coûte rien. Par contre, c'est le slippage qui va vous éclater.
- Les insiders (les devs et leurs potes) : Ils snipent le token à la première seconde après le deploy. Ils connaissent le code du contrat et savent exactement quand le marketing va check-in. Souvent, leurs wallets sont liés via des mixers, mais on les chope direct avec le pattern de la première transaction d'achat qui prend 5% du supply.
- Les snipers avec des bots custom : Des mecs branchés sur des nœuds RPC privés ultra-rapides qui fument chaque pool prometteuse dès qu'elle pop.
- Les whales de tendance : Ils analysent le sentiment social et balancent 10 à 20 ETH / 500 SOL d'un coup sur un token très early. C'est eux qui impriment les grosses bougies vertes sur les charts. C'est le groupe le plus safe à suivre.
| Type de wallet | Vitesse d'entrée | Risque de scam / rug | Stratégie d'auto-exit |
|---|---|---|---|
| Insider | Instantané (bloc 0-1) | Extrême (Rug pull) | TP 50% après un x2, le reste au BE (break-even) |
| Whale Trader | En 5 à 15 minutes | Modéré | Suivre la tendance, exit dès que le volume faiblit |
| MEV Bot | Milliseconde | Faible (c'est eux qui frontrun) | Ne pas copy! (Le script va juste jeter le gas par les fenêtres) |
Erreur fatale #1 : N'essayez jamais de copy trade des bots MEV qui font des sandwich attacks dans le mempool d'Ethereum. Vous ne passerez jamais devant leurs bundles Flashbots. Votre script va juste call une transaction, se manger un revert, et vous allez perdre vos thunes en gas fees. Je me suis fait défoncer la semaine dernière sur Base parce que j'avais oublié de filtrer les contrats des routeurs. Moins 50 balles partis en fumée.
Comment traquer une grosse whale : La logique de parsing
Le plan est simple. On doit parser les logs des DEX (genre Uniswap v3 sur Base ou Raydium sur Solana) sur les deux derniers jours. L'objectif est de target les wallets qui ont fait au moins un x5 ou x10 sur des memes.
Pas besoin de payer des API à des milliers de dollars. Le plan gratuit de QuickNode ou Alchemy suffit largement si on pige comment fonctionnent les logs sur la blockchain. Chaque swap sur un DEX trigger un événement Swap. On dump ces adresses, on les pousse dans une base (une MariaDB fait le taf, pas besoin de monter un Postgres pour des logs basiques), et on check leur PnL.
Au début, je voulais coder le parser en Rust avec de l'inline assembler pour que ça tourne à la vitesse de la lumière... Et puis flemme. Trop de prise de tête pour un MVP. Python avec la lib web3.py va build ça sans transpirer.
On passe au code : Tracker et auto-buyer
Voici un script prêt pour les réseaux EVM (Base, Arbitrum, BSC). Il écoute le nœud RPC, filtre les transactions d'un wallet précis (notre whale cible) et, dès qu'il call une fonction genre swapExactTokensForTokens, le bot envoie instantanément le même buy order.
Rappel : en L2, il n'y a pas de mempool. C'est du FCFS (First Come, First Served) pur. Premier arrivé, premier servi. C'est la vitesse de votre nœud qui décide si vous êtes dedans ou dehors.
Python
import time
import os
from web3 import Web3
from eth_account import Account
# Config. Remplis avec tes infos, gros.
RPC_URL = "https://mainnet.base.org" # Prends un nœud privé, le public va canner direct
PRIVATE_KEY = "TA_PRIVATE_KEY_ICI_NE_LA_LEAK_PAS"
SMART_MONEY_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e" # La whale à track
ROUTER_ADDRESS = "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24" # Exemple de routeur Uniswap v3 sur Base
# WETH et token cible (on extrait l'adresse directement du tx de la whale)
WETH_ADDRESS = "0x4200000000000000000000000000000000000006"
w3 = Web3(Web3.HTTPProvider(RPC_URL))
account = Account.from_key(PRIVATE_KEY)
# ABI minimal du routeur juste pour exécuter le 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):
"""On force le buy au market juste derrière la whale"""
nonce = w3.eth.get_transaction_count(account.address)
# On build la tx. On force le gas pour éviter de se faire frontrun ou de swap sur un énorme dump
tx = router_contract.functions.swapExactETHForTokens(
0, # amountOutMin = 0. Slippage 100% obligatoire sur les memes sinon ça passe jamais
[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, # On double le gas pour passer en tête de bloc
'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)) # En route pour le profit ? À check sur l'explorer...
def monitor_wallet():
print("Script lancé. On attend de voir où la whale pose son sac...")
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:
# On check si la tx vient de notre target
if tx['from'].lower() == SMART_MONEY_ADDRESS.lower():
print("PUT**N ! La whale s'active !")
# Si elle interagit avec le routeur, on y va
if tx['to'] and tx['to'].lower() == ROUTER_ADDRESS.lower():
# En prod il faut parser l'input data pour choper le bon token.
# Exemple ici avec un shitcoin fictif pour le test :
target_meme = "0x1111111111111111111111111111111111111111"
print(f"Copy trade activé. Buy {target_meme}")
buy_token(target_meme, 0.01) # Petite taille pour tester la plomberie
last_block = current_block
time.sleep(0.5) # Anti rate-limit sur le RPC
except Exception as e:
# Erreur classique à 3h du mat pendant que tu dors
print(f"Le loop a crash, reboot du cycle : {e}")
time.sleep(1)
if __name__ == "__main__":
monitor_wallet()Risques, pièges et comment vous allez vous faire rincer
Pendant que votre bot galère à vérifier vos balances, la whale est peut-être juste en train de dump sur sa communauté. Dites-le moi en commentaire si je me trompe, mais il y a une spécialité locale qui s'appelle le Honeypot.
Le piège est vieux comme le Web3 :
- La whale (или le dev) deploy un token avec une fonction cachée qui bloque le bouton sell pour tout le monde, sauf pour une poignée d'adresses whitelistées.
- Elle enchaîne les buy orders sur son propre token pour simuler du volume sur les scanners.
- Votre script voit passer la transaction de la "Smart Money", saute dans le même bloc et buy.
Bravo. Vous venez d'acheter un token impossible à revendre. Vos fonds sont bloqués à jamais. La whale siphonne la liquidité, vous n'avez plus que vos yeux pour pleurer.
La parade ? Avant de valider le buy, le bot doit impérativement simuler la transaction de vente (via un eth_call). Si la simulation de sell renvoie une erreur ou un revert, le token va direct en blacklist. Si vous n'intégrez pas cette sécurité dans votre logique, votre compte va finir à zéro en deux jours.
Puisqu'on parle de simuler des transactions, autant poser le problème cash. La plupart des débutants s'imaginent le truc comme ça : « Je build un parser de logs, j'entre au market sur chaque launch et je ramasse les billets à la pelle ». Tu parles.
Sans simulation pré-trade, t'es juste de la thune gratuite pour les escrocs.
Simulation pré-trade : Comment esquiver les Honeypots
Quand une whale débarque sur un nouveau contrat, ton script ne doit pas bêtement copier l'adresse. Il faut d'abord vérifier si ce shitcoin est revendable. Pour ça, on utilise la méthode eth_call. On simule l'appel de la fonction swapExactTokensForETH en local sur le node, sans envoyer la moindre transaction sur le mainnet.
Si le node renvoie un revert, le token va direct en blacklist. Le script passe à autre chose et tes fonds restent au chaud.
Voilà le bout de code à caler juste avant ta fonction buy_token. J'ai fait l'impasse sur un vrai simulateur avec un fork de réseau. C'est clair que le top c'est de passer par Hardhat ou Anvil, mais là, l'idée c'est de sortir un script rapide au kilomètre.
Python
def check_honeypot(token_address):
"""
Check si le token est clean. On simule un buy et un sell.
Si le contrat bloque la vente, c'est un scam.
"""
# On passe par le router pour check. On teste avec des clopinettes.
test_amount_in = w3.to_wei(0.001, 'ether')
try:
# Simulation du buy via eth_call
# On vérifie juste si ça revert au niveau du contrat
router_contract.functions.swapExactETHForTokens(
0,
[WETH_ADDRESS, token_address],
account.address,
int(time.time()) + 60
).call({'from': account.address, 'value': test_amount_in})
# En vrai, il faudrait simuler le SELL aussi ici.
# Mais ça demande d'avoir déjà les tokens ou de setup un fork local.
# À 3h du mat, un simple check sur le buy fera l'affaire.
# La plupart des gros honeypots crament direct au premier appel du router.
return True
except Exception as e:
print(f"ALERT! Le token {token_address} a failed la simulation : {e}. On skip cette merde.")
return FalseStratégie de sortie : Sécuriser les profits
Acheter c'est facile. Sortir au bon moment sur les meme coins, c'est là que ça devient un art. Ces jetons suivent des courbes paraboliques. Ça pump fort, ça stagne un instant, puis ça dump à zéro dès que les premiers insiders vendent dans l'order book.
J'ai mis en place une stratégie de TP partiel automatisée. C'est du solide :
- Le palier 2x (+100%) : Le script vend automatiquement pile 50 % de la position. C'est bon, tu as sorti ton investissement de départ. Tu es en free ride pour la suite. Mentalement, c'est dix fois plus simple de gérer le trade.
- Le palier 3x (+200%) : On dump encore 25 % du bag restant.
- Le Trailing Stop : Le reste de la position (le moon bag) suit la tendance. Dès que le prix baisse de 20 % par rapport au plus haut local, le script close tout au market.
Alpha du terrain : Ne mets jamais l'amountOutMin à zéro sur une grosse vente. Si tu balances 500 $ de tokens dans une pool qui n'a que 2000 $ de liquidité, les bots MEV vont te frontrun et te découper. Ton script va récupérer des miettes à cause d'un slippage monstrueux. Il faut lisser tes sorties avec de petits ordres.
Où dénicher des adresses Smart Money pour démarrer ?
Un script sans les bonnes adresses, c'est juste du code mort. Où trouver les wallets des whales ?
- Dextools / Dexscreener : Tu ouvres le top des plus grosses hausses des dernières 24 heures. Va dans l'onglet Top Traders ou Transactions. Repère les types qui sont entrés au tout début (blocs 0 à 100) et qui sont sortis au top. Copie ces adresses.
- DeBank / Arkham : Colle l'adresse copiée là-bas. Regarde le winrate du trader. Si le mec affiche plus de 100k $ de balance générés uniquement à partir d'un billet de 500 $ sur des shitcoins, c'est ta cible. Ajoute-le dans ton tableau SMART_MONEY_ADDRESSES.
Le mot de la fin pour les pragmatiques
L'arbitrage statistique et le copy-trading sur les memes n'ont rien d'un bouton magique pour imprimer des billets. C'est une course de vitesse permanente et un tri constant pour éliminer les scams. Tant que ton script tourne sur un RPC node public, tu seras toujours à la traîne. Pour choper un vrai edge, prends un accès à un node privé (comme Jito pour Solana ou des nodes EVM custom optimisés pour envoyer des tx rapides), peaufine tes checks et gère tes risques de manière agressive.
Et surtout, ne mise jamais ce que tu ne peux pas te permettre de perdre. Demain, un projet va revert, le dev va pull la liquidité, et aucun script ne pourra sauver tes fonds.
