The Arena is Automated.Don't Trade with Your Hands.Deploy atomic Pump.fun bundles, orchestrate organic wash trading and automate defensive counter-snipes on Solana. Every number is yours to set — N buy wallets, M exit wallets, per-wallet SOL, delays, tips. Test it all with virtual SOL before spending a single lamport.

Generate exactly N buy wallets + M exit wallets. Deterministic keystore, encrypted on disk, never recreated mid-strategy.

• You choose count: e.g. 10 buy + 5 exit, 25 buy + 10 exit — any topology. Keys are derived and stored in wallets.json / wallets_exit.json.
• Buy wallets are the attack surface; exit wallets are the treasury — separation prevents fingerprinting.
• Generation is atomic and backed up to data/permanent/wallets_gen_<ts>.json before every run.
• In SIM, wallets are virtual holders with SOL balances — same logic, zero on-chain trace.

strategy: spark_fuse / watchfire
buyWallets: 10  → 0x7a3f… 0x9c12… (10 keys)
exitWallets: 5 → 0x3b… (treasury)
keystore: wallets.json (encrypted) + permanent backup
SIM: holders[] with { solBalance, tokens } — no RPC cost

Master wallet funds every buy and exit wallet in one pass. Dynamic topping ensures each buy has enough SOL to execute.

• Funding = max(buyAmount, fundAmount) + feeBuffer per wallet. Master is checked before each transfer — if short, it fails fast with clear balance hint.
• Exit wallets get a small gas reserve (0.003–0.005 SOL) — enough to sell and sweep, minimal stranded SOL.
• Verification is authoritative: confirms via getSignatureStatuses + getTransaction postBalances — never trusts a lying getBalance (random RPC lag).
• Wash pre-funding is separate: after creation, every buy wallet is topped to min 0.02–0.30 SOL for volume legs.

Master: 1.2 SOL
→ buyWallet 1: fund 0.25 SOL (buy 0.20 + 0.05 buffer) ✓ confirmed
→ buyWallet 2: fund 0.25 SOL ✓
→ buyWallet 3: fund 0.25 SOL ✓
→ exitWallet 1-2: fund 0.003 SOL each ✓
Total: 0.756 SOL funded · 0.444 SOL left for wash/jito
Verify: postBalances[wallet] == pre + 0.25 SOL

One click deploys the full autonomous flow. Creation, buys, wash, transfers and monitors are orchestrated — you watch, the engine executes.

• Load a preset (Spark Fuse 1 SOL → Sovereign Book 10 SOL) — it populates every module. Or craft a custom strategy in the editor with delays, slippage and tip controls.
• Creation flow is visual: Fund → Create Token (image + metadata) → Bundle Buys (jittered clusters 0.5×–3.0×) → Wash → Transfer → Arm Defender/Ladder/SL.
• Autonomous means autonomous: wash, defender and ladders run without clicks. Manual commands remain available in parallel.
• Every step logs in English with SOL/token counts and links to explorer — no hidden state.

[1] FUND      3×0.25 + 2×0.003  → 0.756 SOL
[2] CREATE    metadata + pump.fun create  → mint 7x9f…
[3] BUNDLE    3 buys ×0.20 SOL (clusters) → 13.5M tokens  (jito chunk0 atomic)
[4] WASH      12 cycles ×0.12 SOL chaotic → 4.92 SOL vol
[5] TRANSFER  Buy→Exit 60% via racing → 8.1M to treasury
[6] ARM       Defender 30% 800ms + Ladder 1.5×–10× + SL -25%

Buy or sell from any wallet set with exact percentages or SOL amounts, distributed across N wallets with optional delays.

• Buy: set SOL per wallet or % of Master — engine splits across buy wallets with jittered clusters (natural distribution).
• Sell: 25% / 50% / 100% or custom pct per wallet; choose buy-wallets vs exit-wallets vs deployer. Supports Jito bundles or racing RPC.
• Delay modes: instant, gradual (10–20s jitter), or VWAP-style. Every leg is logged with tokens → SOL.
• Example: 5 wallets × 0.20 SOL = 1.0 SOL buy → ~2.8M tokens each, 13.5M total in <2s.

$ launchbundle buy --wallets 5 --amount 0.20 --delay 200-600ms --jito
→ wallet1 0.19 SOL → 542k tokens ✓
→ wallet2 0.22 SOL → 598k tokens ✓
→ wallet3 0.18 SOL → 501k tokens ✓
→ wallet4 0.21 SOL → 571k tokens ✓
→ wallet5 0.20 SOL → 553k tokens ✓
Total: 1.00 SOL → 2.76M tokens · avg 0.00000036 SOL/token

Move tokens from buy wallets to exit (treasury) or sweep everything back to Master — SOL + tokens + ATA rent.

• Transfer: Buy → Exit at 50–70% with racing. Exit wallets become the sell surface — reduces fingerprinting.
• Sweep: closes ATAs, burns dust, recovers rent (0.002 SOL per ATA) and sends all SOL/tokens to Master. Works for any mint.
• Sweep is idempotent — run it repeatedly, it only sweeps what exists. Logs every wallet.
• In SIM, transfer/sweep update holders[] instantly — same UX, no chain wait.

$ launchbundle transfer --from buy --to exit --pct 60 --racing
→ 5 wallets ×60% → 8.1M tokens to exit (0.4s)

$ launchbundle sweep --mint 7x9f…
→ wallet1: sold 1.2M on curve → +0.034 SOL → closed ATA +0.002
→ wallet2: sold 0.9M → +0.028 SOL → closed
→ Master: +0.42 SOL total (sweep complete)

Generate real on-chain volume with paired sell/buy legs. Chaotic mode randomizes amounts and wallet order for organic charts.

• Each cycle = 2 legs: sell 0.02–0.35 SOL then buy same wallet back. Net ≈ 0, gross = 2× leg volume.
• Pre-fund step ensures every buy wallet has 0.02–0.30 SOL before wash — without it legs are micro.
• Chaotic: randomizes SOL per leg and wallet order, adds jitter so no two cycles are identical. Jito optional.
• Logs: Vol / Fees / Net / txs per cycle — transparent P&L. No fake prints, all on-chain.

$ launchbundle wash --cycles 12 --leg 0.08-0.18 --chaotic --rpc 20
Cycle 1: sell 0.11 → buy 0.10 (wallet 3→7) vol 0.21
Cycle 2: sell 0.14 → buy 0.13 (wallet 1→5) vol 0.27
...
Total: 12 cycles → gross 4.92 SOL · fees 0.08 · net +0.04
Chart: volume +1.8×, holders unchanged

Defender counters any external buy ≥ threshold by selling 30–100% of that buy in 1–5 Jito-backed waves within 800ms. Accumulator does the inverse on dips.

• 100% deterministic: threshold jitter 0.7–1.0× never exceeds minSol, so any external buy ≥ minSol always triggers.
• Amount jitter 0.8–1.2× and wave splitting keep it organic. Jito backrun when JITO_AUTH_UUID is set, otherwise racing RPC.
• Accumulator: if price drops X% → buy Y SOL × Z times, same wave/jitter engine, opposite direction.
• Both can run together; Market Maker pauses them while its grid is active. 800ms polling + mempool watcher.

defenderMinSol: 0.20
responsePct: 30%  (of external buy)
waves: 1  •  checkMs: 800ms  •  Jito: true
External: +0.42 SOL (predator)
→ Defender: 0.42×30%×1.1 jitter = 0.139 SOL sell in 1 Jito bundle (backrun, block #0)
Accumulator: drop -8% → buy 0.15 SOL ×3 (same engine)

Create a price grid that provides depth. The MM places staggered buy/sell orders around mid-price, harvesting spread while supporting the chart.

• Grid: set levels (e.g. ±2%, ±4%, ±6%) with size per level. MM auto-rebalances as price moves.
• Spread capture: buys dips, sells rips — each fill is a real on-chain trade, not spoofing.
• Runs as the sole live strategy while active — it pauses Defender/Accumulator to avoid conflict, then resumes them when stopped.
• Live controls: adjust levels and size without restarting; PnL and fills stream to the log.

mid: 0.00000042 SOL
levels: -6% 0.05 SOL buy • -3% 0.05 buy • +3% 0.05 sell • +6% 0.05 sell
→ price dips -3% → buy 0.05 fill → inventory +119k
→ price rips +3% → sell 0.05 fill → spread +0.003 SOL
Depth: 0.20 SOL total · 4 levels · auto-rebalance

Scale out at multiples, cut losses at the peak, and ladder without clicking. All share the same PanelState and can be armed together.

• Ladder: sell 25% at 1.5×, 3×, 6×, 10× (customizable) via 5s refreshState poll — no manual timing.
• Stop-Loss: -25% from peak, optional trailing 15%/8% (arms at +15%, sells if drops 8% from high). Sells 100% instantly.
• Gradual: 5–8% chunks with 10–20s jitter over 2 min — hides size, avoids price impact.
• VWAP: 3 phases — 5% every 2–4s, 10% every 3–6s, final Jito bundle flush. All exits log tokens → SOL.

ladder: [1.5× 25%, 3× 25%, 6× 25%, 10× 25%] → 100% scaled exit
stop: -25% from peak • trailing 15/8
gradual: 5–8% ×12 rounds • 10–20s jitter
VWAP: p1 5%×6 → p2 10%×4 → p3 Jito flush
→ 1.5× hit → sold 2.1M (25%) +0.18 SOL

Snipe new launches or mirror a wallet. Millisecond triggers, Jito bundles, and copy-trade with configurable buy amount and wallet count.

• Sniper: watches pump.fun / Raydium for new mints, triggers on creation with buy amount and slippage, Jito bundle for block #0.
• Copy Trade: follow any wallet — on their buy, we buy same mint with your size, optionally via Master. Latency <1s.
• Both use racing + Jito, respect rate limits, and log detected/bought/failed/rejected counts.
• Combine with Defender: snipe then immediately arm defense — the flow that wins launches.

$ launchbundle sniper --buy 0.15 --slippage 8 --jito --rpc 50
→ new mint 9x... detected 0.4s → buy 0.15 SOL → landed block #0

$ launchbundle copy --wallet 7x... --amount 0.05 --wallets 1 --jito
→ target buys 0.8 SOL → we buy 0.05 SOL → +12% in 2s

The same engine, frozen and verified. Test any strategy with virtual SOL and holders — no chain cost, no risk, identical logs and distribution.

• Frozen: simulation engine passed all tests and is locked — deterministic, no drift from REAL.
• Virtual master + virtual holders + virtual DexScreener data — every module (wash, defender, ladder) runs the same code path.
• Use SIM to validate before mainnet: load Spark Fuse, run the lesson, check PnL, then switch to REAL with one toggle.
• SIM and REAL share PanelState shape — switching is instant, no rebuild.
• Monte Carlo: 1000 randomized runs of your settings output P90/P50/P10 profit percentiles + a suggested stop-loss — size your launch and protect capital before spending a single lamport.

$ launchbundle --sim launch --strategy spark_fuse
[SIM] FUND 3×0.25 ✓  [SIM] BUNDLE 13.5M tokens ✓
[SIM] WASH 12×0.12 → 4.92 SOL vol ✓
[SIM] DEFENDER 0.42→0.13 sell ✓  [SIM] LADDER 1.5× hit ✓
[MONTE CARLO] P90 +2.1 · P50 +0.4 · P10 −0.9 SOL → SL −25% auto
PnL: +0.08 SOL (virtual) — no SOL spent

ML suggests optimal wash size, defender thresholds and ladder steps from historical launches — you keep full manual override.

• Learns from your jito-metrics.json, holder distribution and landed bundles to propose tip, jitter and wave counts.
• Suggests buyAmount clusters and funding buffers that minimize stranded SOL while maximizing land rate.
• Every suggestion is a starting point — you can lock any param and let ML tune the rest.
• Runs locally; no data leaves your personal database unless you enable SaaS multi-tenant.

ML input: 106 bundles · 55.7% landed · avg tip 1.5M
Suggestion: wash leg 0.11 SOL (was 0.15) → +4% net
            defender 0.18 SOL / 28% (was 0.20/30) → -12% fees
Accept? [y/N] → apply to strategy

You bring your own RPCs — Helius, QuickNode, Triton, any provider. Each trader connects 1 to 150+ private endpoints stored encrypted in their own database, never shared, never pooled. Our internal fleet is an EXAMPLE for latency reference only — users never use our nodes.

• BRING YOUR OWN: paste your Helius / QuickNode / Triton endpoints in Panel → RPCs → Test (getSlot) → Save. The engine races through YOUR fleet — 1 for SIM, 20 for live, 150+ for war-mode sniping.
• The 150-RPC examples on this page are OUR internal fleet with real millisecond timings (p50 0.35s @50 RPCs) — shown as a benchmark, not something you use. Your nodes are private to you; nothing is ever shared or pooled.
• Per-user isolation: users.rpc_endpoints (JSONB, encrypted at rest) scoped by user_id. User A never sees or pays for User B's nodes, never hits their rate-limits.
• Smart routing per request: rpcCall resolves via getUserActiveRpcUrls(userId) with 30s cache — if you add custom RPCs, every create/buy/defender/wash leg races through yours; if empty, a safe system fallback is used.

1 RPC   → cold SIM       1.2s p50
20 RPCs → live trading   0.6s p50
50 RPCs → launch         0.35s p50
150+    → war-mode        <0.3s p50   (ours, internal)

YOU BRING YOUR OWN:
Helius → https://mainnet.helius-rpc.com/?api-key=xxx
QuickNode → https://solana-mainnet.quicknode.pro/xxx
Triton → https://rpc.mainnet.triton.one/xxx
→ Panel → RPCs → Test → Save (encrypted per user)

Jito now requires an authenticated UUID to auction your bundles. Request yours via a support ticket in the Jito Discord, paste it in Panel → Jito — stored encrypted per user, injected as x-jito-auth only for your bundles. Without it, bundles are ACCEPTED but never auctioned.

• HOW TO GET IT: join the Jito Discord (discord.gg/jito) → open a support ticket → ask for a Block Engine UUID → you receive <xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx>. Paste it in Panel → ⚙️ Jito → Save. That's it.
• Why it matters: since Jito enforced UUID auth, bundles submitted without x-jito-auth are ACCEPTED (HTTP 200 + valid bundle ID) but silently marked Invalid and NEVER auctioned — no land, regardless of tip. The panel shows JITO AUTH ✓ only when YOUR valid UUID is present.
• Per-user isolation: users.jito_auth_uuid encrypted at rest, scoped by user_id — your tips, your bundles, your land rate, never shared.
• 9 regional Block Engines (NY, Amsterdam, Frankfurt, London, Dublin, SLC, Singapore, Tokyo), 2 req/s per region, tip floor/cap configurable, only paid if the bundle lands.

1. Jito Discord → support ticket → Block Engine UUID
2. Panel → ⚙️ Jito → paste UUID → Test → Save
3. Launch --jito → bundles under YOUR lane

With UUID:
  bundle [create + 3 buys + tipTx] = 5 txs chunk0
  → ACCEPTED (your lane) → LANDED 0.9s · CU 1.4M

Without UUID:
  → ACCEPTED but NEVER auctioned (silent Invalid)