FOMO Copy-Trading

2 · How the Top Wallets Were Identified

The Problem

The FOMO leaderboard shows handles (@unipcs, @DumbCrayonEater…) and USD P&L, but not the underlying wallet addresses. The app only shows a relayer-style "From" label on transfers — never the raw on-chain sender. We had to match screenshots to chain data ourselves.

The Method (EVM wallets #1–9)

1. Get trade-history screenshots from each leaderboard account (user-provided).
2. Identify the candidate token contracts. For each token in the screenshot, resolve the contract address via DexScreener/GeckoTerminal on Robinhood Chain.
3. Pull real Transfer events. Query the RH-chain RPC (rpc.mainnet.chain.robinhood.com) for ERC-20 Transfer logs on those token contracts, or use Blockscout CSVs.
4. Match by exact amount + block timestamp. The decisive step: a screenshot row like "15,000 NANOGPT @ 14:02" matches an on-chain transfer of exactly 15,000 NANOGPT to a specific address within ±2 minutes. Decimals matter (ZCAT=8, most=18).
5. Confirm ecosystem membership. The same faucet batch bots pay multiple wallets in a single transaction (e.g. a 61.4M XXX batch paid #1–#9). A shared batch tx = confirmed membership.

The Method (Solana wallet #10)

1. Use Solana RPC (getSignaturesForAddress) to list txs touching the candidate's token accounts.
2. Decode each tx via Helius (public RPC rate-limits; Helius key stored in Hermes env).
3. Match postTokenBalances deltas + blockTime against the screenshot (e.g. XSOL 0 → 185.008 @ 06:51:07 UTC exact).

Verification

Every wallet match was confirmed against real on-chain data (RPC + Blockscout CSV + Helius). Screenshot rows matched 11/11 per account where full history was available. Full tables: docs/fomo-top10-identification.md.

3 · The Top-10 Wallets — Performance, Transactions, Positions

The Complete Table

17 tracked wallets. Tiers from the 3-month backtest (2026-09-08): Tier-1 COPY = full paper positions · Tier-2 = half-size · Tier-3 = watch-only notifications. Top-30 expansion also flagged @frankdegods + @motiyawerey as Solana-native (not copyable). See docs/fomo-top30-expansion.md.

Behavior classes (decides which strategy applies)

• Pure accumulators (#1, #2): receive from faucet bots, never sell. Receipt → pump signal (the H3/H5 edge).
• Active traders (#3, #7, #9 + most #4–10): buy via the settlement bot, sell back to it, some run perps. Their sells are real exit signals (H4 inverted for traders).
• Solana scalper (#10): 4,417 buys / 576 sells in 5 weeks. His receipts do NOT pump; copy-trading him loses.

Faucet ecosystem (the signal source)

Backtest performance by wallet (5-week window, Aug 1 – Sep 7 2026)

Key measured token outcomes (dump-monitor exit, net of slippage)

Live paper positions (opened overnight)

4 · 3-Month Comprehensive Backtest (Jun 10 – Sep 8, 2026)

Window: 90 days on Robinhood Chain · Data: Alchemy transfers for 17 wallets (~89K receipts), GeckoTerminal daily OHLCV for 283 tokens · Method: every faucet-sender IN receipt is an entry; forward returns close-to-close at +1d/+2d/+3d/+7d/+14d/+30d; filters: value ≥ $100, pool reserve ≥ $5K, equities/stables excluded.

Aggregate — qualifying signals (faucet + ≥$100 + ≥$5K), n=188

Read: ~47–57% win at 1–3d with negative average but near-flat median — a positive-skew lottery. Most receipts are small losers/flat; the winners are large. Wallet selection matters enormously.

Per-wallet verdicts (qualifying signals)

Copy tiers (implemented in the paper trader)

Full per-wallet detail (strategy / execution / entry / exit / proposed copy process per wallet): docs/backtests/fomo-3month-backtest.md · raw signals: data/backtests/fomo-3month-backtest.json.

5 · How to Copy-Trade These Accounts — Simple English

Step-by-step (no code)

1. Get an alert. The system watches all 17 wallets every 10 minutes. When a whitelisted faucet bot sends a token to a Tier-1 wallet (unipcs, The__Solstice, change), and the token has a real pool ($5K+), you get a PAPER OPEN alert. Tier-3 wallets send WATCH alerts (no trade). Alerts go to the FOMO leaderboard bot with token name, pool, price, sender.
2. Check the basics. Only trade tokens from the whitelisted faucet bots (the table above). Ignore anything sent by other senders. Ignore dust (receipt worth <$100). Ignore PONS and big stables/majors.
3. Buy small. Put in a small order — no more than 5% of the pool's total size, capped at ~$500. On a $30K pool that's ~$500 max; on a $3K pool that's ~$150. This keeps your buy from moving the price against you.
4. Hold. Keep the position for at least 24 hours.
5. Exit rules (the important part):
   • At 24h: if the token is up less than +50% → sell now (the pump faded).
   • At 24h: if the token is up more than +50% → hold to 72h (let the winner run).
   • Hard stop: if it's ever down more than -60%, sell immediately (pool collapse guard).
   • 72h cap: always sell by 72 hours no matter what.
6. Log it. Record the trade so we can measure whether the edge still works (win rate, median return).

What you should NOT do

• Don't copy the Solana wallet (#10). It's a fast scalper; its buys don't pump, and following it loses money (backtest: 19% win on its own round-trips).
• Don't go big. These are micro-liquidity pools. Big orders = you become the exit liquidity. Size is capped by pool depth.
• Don't hold forever. The edge is a 24–72h pump window. After that, tokens routinely dump (many -60% to -97%).
• Don't chase the pump. If you see a token already up 5x, you've missed the entry; the receipt alert is the entry signal.

How much can you make (honest numbers)?

Based on 36 real measured trades over 5 weeks, net of modeled slippage at $500/trade. Past performance ≠ future results; this is exactly what the live paper period is validating forward.

6 · How to Copy-Trade — Detailed Technical Version

Architecture

Robinhood Chain RPC (4663) ──▶ Signal Engine ──▶ Filter Stack ──▶ Signals JSONL
                                                       │
                                                       ▼
                                        Paper Trader / Executor
                                        (size = min($500, 5% reserve),
                                         dump-monitor exits, risk caps)
                                                       │
                                                       ▼
                                        RH router (0x4a86009a… proxy → swap 0x3e0f9c3c)

5.1 Data sources

5.2 Signal engine (EVM)

# topics: Transfer(address,address,address) — OR-list of 17 wallet addresses
topics = [TRANSFER_TOPIC, None, [pad(w) for w in WALLETS]]
logs = rpc('eth_getLogs', {'fromBlock': latest-N, 'toBlock': 'latest', 'topics': topics})
# per log: sender = topics[1], receiver = topics[2], token = log.address
# filter stack (order matters):
#  1. sender ∈ H3_WHITELIST ∪ FAUCET_PREFIXES
#  2. symbol ∉ {PONS, USDG, WETH, cbBTC, OPAI, COIN, SPCX, XOM, gld}
#  3. value = amount * price_usd >= $100            (dust floor)
#  4. pool reserve_usd >= $5,000                    (liquidity floor)
# state: seen_txs dedup -> data/fomo_state/signal_state.json
# output: data/fomo_signals_.jsonl

5.3 Paper trader / executor logic

size      = min(500.0, 0.05 * pool_reserve_usd)     # pool-relative cap
entry_px  = price * (1 + size/(reserve+size))        # constant-product entry slippage
exit_rules (checked every run, live proxy for dump-monitor):
  age >= 72h                          -> exit
  age >= 24h and r24 <  +50%          -> exit (pump faded)
  age >= 24h and r24 >= +50%          -> hold to 72h
  r <= -60% anytime                   -> hard stop
exit_px   = price * (1 - size/(reserve+size))        # exit slippage
risk:
  MAX_CONCURRENT = 2
  DAILY_LOSS_CAP = $25  (closed PnL, UTC day)
  KILL file at data/fomo_paper/KILL disables new opens
state: data/fomo_paper/positions.json + trades_.jsonl + summary_.md

5.4 Execution path on RH chain (Phase 2, pending)

1. Quote: (a) Uniswap API /v1/quote with chainId 4663 (needs free key), or (b) reverse-engineer the 0x3e0f9c3c calldata shape (decode a real swap tx), or (c) use pons-family routers directly for the actual signal tokens.
2. Approve: ERC20.approve(router, amount) once per token.
3. Build + sign: assemble swap calldata, sign with executor EOA via eth_account.
4. Submit: eth_sendRawTransaction → poll eth_getTransactionReceipt → confirm.
5. Gas: RH chain gas ~0.3 gwei (cap 1 gwei) — cost is negligible.

Test executor EOA (Phase 0): 0x62db201e3533684423Ae5908eF77305aAF512B64 — key ~/.hermes/secrets/fomo_executor_rh.json (0600, test-only, unfunded).

5.5 Solana #10 — why rejected (technical)

Decoded 6,025 txs (Helius batch-25, Aug 1–Sep 7): 4,993 token events = 4,417 buys / 576 sells across 51 mints. Receipt-copy at 24h: 23.1% win >0%, median -18.5%. FIFO mirror of his round-trips (1,035) at hourly OHLCV: 19.0% win, avg -25.9%. Conclusion: he is the exit liquidity, not a signal. Strategy is watch-only via Helius.

5.6 Deployment & ops

• Hermes cron 9d131c38fdb7 — paper trader every 10 min (no_agent, silent unless action).
• Hermes cron abee91bd67a2 — morning report 08:30 Sydney.
• Wrapper: ~/.hermes/scripts/run_fomo_paper_trader.py → repo scripts.
• Repo-first: all code in jahrfm/fomo; deploy to dedicated VPS for Phase 2 (keys never on Hermes box for live).
• Mirrors: Obsidian vault + Notion FOMO Watchlist DB + this site.

5.7 Reproducing the backtest

python3 scripts/copy_trade_backtest.py          # EVM side (uses data/rh_5w.csv + forward_returns.json)
python3 scripts/fomo10_backtest.py              # Solana side (reads /tmp/fomo10_txs.jsonl + fomo10_gt.json)