RGPL — Pump.fun Sniper Bot (Rust)

Bot de sniping autonome sur Pump.fun (Solana), architecture hexagonale Rust. Positionnement : sniper réactif en temps réel — détection (t+2-4 s, feed gratuit) → filtres légers → achat immédiat → sorties pilotées par signaux (trailing, flux mort, whale exit, dev-sell) avec des réflexes temps réel sur les positions détenues. Il ne court pas la course au slot-0 (perdue d'avance à budget zéro) et ne recopie personne : il juge seul. Les horloges ne sont que des filets de sécurité.

Mode SCAN-WEB — mesure sur données réelles (zéro lamport)

Le bot peut tourner en observation pure sur le mainnet : il détecte chaque token créé sur pump.fun via l'API frontend publique (gratuite, sans clé), l'analyse avec le vrai pipeline de décision, et exécute les trades en paper (aucune signature, aucun SOL dépensé). Chaque décision est journalisée pour l'audit et la calibration.

SCAN_WEB=true cargo run -p backend --bin sniper-bot

• Détection : poll de frontend-api-v3.pump.fun/coins (3 s, gratuit)
• Pré-filtres : metadata + socials + créateur — 60-80 % rejetés sans un appel RPC
• Analyse profonde : Helius free tier uniquement pour les survivants (~6 appels)
• Prix temps réel : dérivé du mcap du feed — TP/SL paper sur vrais mouvements
• Contrefactuels : chaque token rejeté est suivi 30 min — bon rejet ou manque à gagner ?

Journaux rejouables dans config/sessions/YYYY-MM-DD/ : market_feed.jsonl (créations + latences), decisions.jsonl (verdicts, rejets, trades, circuit breaker), counterfactuals.jsonl (verdict de la réalité sur les rejets). Rapport :

cargo run -p test-harness --bin session-report

⚠️ État — octobre 2026

Le cœur est fonctionnel et testé unitairement (440+ tests), mais aucune exécution mainnet réelle n'a jamais eu lieu. La validation doit passer par la chaîne locale (validateur + programmes mainnet, simulation Monte Carlo calibrée sur la config live). Voir todo.md pour le tableau de bord exact.

Architecture

rgpl/
├── crates/
│   ├── domain/          # Cœur métier : entités, ports, constantes, risk scoring,
│   │                    # parsing Anchor (CreateEvent + TradeEvent), fee service
│   ├── application/     # Cas d'usage : trading engine (TP/SL/trailing/DCA),
│   │                    # event processor (filtres pre-buy), analyzer,
│   │                    # dev monitor, momentum, telegram, position watch
│   ├── infrastructure/  # Adapters : flux WS/gRPC Yellowstone, trading executor
│   │                    # (SDK SWQoS 18 relais, JitoDontFront), config, métadonnées
│   ├── backend/         # Composition root : binaire sniper-bot, API REST (9876),
│   │                    # create-token, trading-simulation (Monte Carlo)
│   ├── test-harness/    # Tests : pnl/validator/integration/jito/
│   │                    # pumpfun-integration + session-report
│   └── sol-trade-sdk/   # SDK Pump.fun/PumpSwap/Jupiter (instructions, params DEX,
│                        # soumission SWQoS multi-relais)
├── packages/
│   ├── ui/              # Dashboard Dioxus (production + dev/sandbox)
│   ├── api/             # Server functions
│   └── web/             # Entry point fullstack
└── config/              # settings TOML + data dir (positions.json, ml_weights…)

Flux de bout en bout (octobre 2026)

WS logsSubscribe / gRPC Yellowstone
├── CreateEvent ──► event_processor ──► filtres (scoring 10 facteurs, taxes,
│   bonding curve, freeze/mint authority, concentration owners, social via
│   gateway IPFS) ──► gate break-even (frais réels + coûts fixes) ──► buy
│   (SWQoS multi-relais, blockhash caché, params pré-résolus)
└── TradeEvent ───► routeur event-driven :
    ├── prix live des positions (sub-100 ms, zéro RPC) → réveil immédiat du
    │   verdict TP/SL/trailing (tick 2 s en fallback)
    ├── momentum nourri de vrais trades (aller-retours wash exclus)
    ├── dev-sell d'un mint en position → vente de protection immédiate
    └── whale-sell d'un top holder snapshoté à l'entrée → « 🐋 Whale exit »
        (≥10 % de sa stack en une tx, ou ≥25 % cumulé — zéro RPC)

Graduation ─────► marqueur horodate sur la position : pendant ~5 min le mur
d'achat protocolaire BOOST (buyback+burn) suspend la sortie stagnation ;
ensuite le trailing est resserré (×0.5).

Démarrage rapide

cp .env.example .env          # renseigner RPC/WS + clé privée (jamais commitée)
cargo run --release --bin sniper-bot           # bot + API :9876
cargo run --release --bin sniper-bot -- --local # mode local (paper/mock)

Le scan démarre désactivé (scan_enabled=false) — activation via le dashboard ou POST /scan/on. PAPER_TRADING=true simule tout le pipeline sans tx on-chain.

Test local (zéro SOL réel)

# 1. Validateur local avec les VRAIS programmes mainnet (cache ~/.rgpl/validator/)
cargo run -p test-harness -- validator --rpc-url http://127.0.0.1:8899

# 2. Exercer le vrai chemin buy/sell contre le BPF Pump.fun
cargo run -p backend --bin create-token -- --exercise

# 3. Suite de tests
cargo run -p test-harness -- validator --rpc-url http://127.0.0.1:8899
cargo run -p test-harness -- pnl
cargo test -p application -p domain -p backend --features trading

# 4. Simulation Monte Carlo — avec la config RÉELLE du bot
cargo run -p backend --bin trading-simulation -- --from-live-config --tokens 1000

Économie d'un trade (réalité 2026)

Poste	Valeur
Frais bonding curve	1,25 % buy + 1,25 % sell
Frais PumpSwap post-grad	1,25 % → 0,30 % selon mcap
Rent ATA	~0,00204 SOL (4 % d'un trade de 0.05)
Base fee	0,000005 SOL × 2
Tip Jito	floor dynamique (défaut 0.001 SOL)

Défauts corrigés : BUY_AMOUNT_SOL=0.05 (0.01 rendait les coûts fixes insurmontables), JITO_TIP_SOL=0.001. Le gate break-even pre-buy intègre désormais coûts fixes + priority fee dimensionnée correctement (µlamports/CU × CU). Le PnL réalisé est mesuré on-chain (delta SOL du payer via pre/postBalances — fees, tips et rent inclus).

Sécurité

• Clé privée : jamais dans l'environnement process, jamais loggée (redact_url, SharedEnv thread-safe)
• unsafe std::env::set_var éliminé (passage explicite de la config)
• Whitelist uploads, CORS configurable, guards admin JWT (API)
• Sécurité financière : circuit breaker, pause marché, blacklist auto, limite de perte quotidienne, max ownership, wallet pool
• Protections whale/rug (oct. 2026) : Mayhem Mode skip tant que le token est sur curve (AVOID_MAYHEM_COINS, l'agent peut être net-seller), whale exit watch (les top holders snapshotés à l'entrée sont surveillés pendant la détention — vidage de stack → sortie immédiate), fenêtre de grâce BOOST post-graduation, anti-wash-trading dans le momentum
• Détail complet mécanisme → parade : KNOWLEDGE.md § 11

Documentation

• docs/trading/architecture.md — architecture détaillée
• docs/trading/testing.md — chaîne de validation locale complète
• docs/trading/security.md — surface de sécurité
• todo.md — état réel du projet, tâches restantes
• log.md — journal des sessions