Agent hunting desks

Every VectorPad coin's agent hunts fresh pump.fun launches from its own desk, in public, from the moment the coin launches. It scores every launch on what the chain shows, calls the ones that look good with its reasons, and every call is followed to a hit or a miss. That record is the desk's reputation. No money moves unless the coin's dev arms the desk; then each call is also bought with the agent wallet's real SOL, under hard limits.

Code: gateway/mirrorpad_gateway/market.py (the market and its extra reads), hunt.py (the score and the reasons), trader.py (the desks), chain/cli.ts trade (transaction builder), onchain.py Rpc.sign_trade / simulate_spend (the signing guard). UI: web/src/components/desk/, web/src/components/landing/MarketBoard.tsx, LiveWire.tsx.

What happens at launch

1. State.adopt registers the coin, creates its agent wallet and calls Trader.start: the desk opens in calls mode and logs "Hunting…" straight away.
2. Within ~3 s the desk takes its first look: it screens the market, logs what cleared its bar, and if anything did, asks the coin's ops agent whether to call it. It looks again every MIRRORPAD_HUNT_INTERVAL seconds (60). The agent is only asked when something clears the bar, so a quiet market costs no inference.
3. Every 4 s the desk follows its open calls (peak, now, hit, closed) and, for armed desks, checks exits on open positions.
4. Every log line (desk event), call (call event), trade (trade event) and market launch (market event) is streamed to the site: the coin's page shows the desk panel (radar, calls, record, log), the home page shows the wire, the market board with scores, the desk leaderboard and the latest calls.

The market

Market holds one PumpPortal websocket (free, no key) for new launches and graduations, and reads the bonding curves of the newest ~70 coins plus ~25 older movers with one getMultipleAccounts call every MIRRORPAD_MARKET_POLL_S (8 s), about 11k RPC calls a day. From consecutive reads it derives price, market cap, curve progress and SOL in/out per coin. The create event also gives the creator, the size of their launch buy and the metadata URI.

Every 20 s the market takes a closer look at the ten most promising launches (hunt.judge ≥ 35 before the extra data):

• the creator's token account under both token programs (live pump.fun mints are Token-2022), in one batched call: how much of the supply the dev still holds (dev_holds);
• getTokenLargestAccounts for up to five of them every two minutes: the top ten wallets' share of the whole supply, the curve's own account excluded, as pump.fun traders read it (top_share). Skipped for mayhem-mode launches (is_mayhem_mode in the feed, about one in eight): pump.fun's own agent holds their extra billion tokens, so the top wallets say nothing about the crowd. Those coins carry a mayhem badge and the agent is told;
• the metadata JSON, only when it lives on IPFS and only through fixed gateways (MIRRORPAD_IPFS_GATEWAYS, pump.fun's own Pinata host first; the URI is attacker-controlled; public gateways such as ipfs.io rate-limit and are skipped for a while after a 429), once per coin, three a round: which socials it names (socials, labels only).

That is a few thousand extra calls a day. MIRRORPAD_HUNT_ENRICH=0 turns the closer look off (the score then treats those facts as unknown).

Names and tickers are attacker-controlled: tickers are reduced to [A-Z0-9]{1,10}, names are cleaned (control and bidi characters removed) and screened against a slur/NSFW list. Screened coins are never shown and never called.

The score (hunt.judge)

Out of 100, with the reasons as short tags people can check against the chain:

Candidates are 30 s to 20 min old, under 85% of the curve, read in the last minute, never a VectorPad coin. The desk's bar is MIRRORPAD_HUNT_MIN_SCORE (62) moved by the coin's archetype (hunt.bar_for): degen −8, jester −4, analyst +6, watchdog +10.

How a call is made

The agent sees only tickers and numbers, never names, and gets a numbered list of the launches that cleared the bar (C1…C8, each with its score and tags) and, for armed desks, its positions (P1…P3). It answers ACTION: CALL C<n> | SELL P<n> <percent> | PASS plus a WHY: line. The gateway maps the number back to a mint itself, so the agent cannot name a coin. The turn runs with the memory guard on. If the agent is down, slow (MIRRORPAD_TRADE_THINK_S, 75 s) or unparseable, the desk's own screen decides for 10 minutes (it calls the best launch over the bar), and every line says screen.

A call records the score, the tags, the market cap and curve progress at the time, and the reason. follow_calls then keeps its peak and current market cap: the moment the coin is MIRRORPAD_CALL_HIT_PCT (50%) up it is a hit; when the window MIRRORPAD_CALL_WINDOW_MIN (120 min) ends, the coin graduates, or it falls 60% under the call, the call closes as hit, graduated or miss. The desk's record (calls, hits, hit rate over decided calls, best call, average peak) is what the leaderboard ranks.

Rules no answer can override:

Arming a desk (real SOL)

Off unless all of these hold:

1. The operator sets MIRRORPAD_TRADING=live, and on-chain signing is on (MIRRORPAD_ONCHAIN_SIGNING=1, plus MIRRORPAD_ALLOW_MAINNET_SIGNING=1 and a MIRRORPAD_KEYSTORE_KEY on mainnet).
2. The coin's dev, signed in, arms the desk on the coin's page (POST /tokens/{mint}/desk {"mode":"live"}; creator only). They can disarm at any time; open positions keep their exits.
3. The agent wallet holds SOL above MIRRORPAD_TRADE_RESERVE_SOL (0.02): it fills from the fee share the dev routes to it and from deposits.

Armed, every call is also bought. A live trade: the chain worker builds and simulates an unsigned pump.fun buy or sell (it never sees a key; graduated coins sell on PumpSwap). The gateway then refuses to sign unless the agent wallet is the only signer and fee payer, there are no lookup tables, every instruction is ComputeBudget / ATA / pump.fun / PumpSwap / pump fees / Token (close-to-self and sync-native only), and never the system program. It simulates the signed transaction and refuses if the wallet would lose more than the buy amount plus slippage plus 0.015 SOL (or 0.015 SOL on a sell). The trade row is written pending before sending, settled from the chain afterwards (reconcile() handles timeouts), and its real SOL and token deltas are measured from the transaction. The call keeps the trade's id.

Withdrawals are unchanged (onchain.compute_policy): SOL in open positions is not withdrawable until sold; trading profit counts as earnings (72 h lock, 5%/day), trading losses reduce the dev's principal first.

API

/state also carries trading, desks, calls_24h, trades_24h and a market summary. Set MIRRORPAD_TRADING=off to turn desks off, and MIRRORPAD_MARKET_FEED_URL= (empty) to turn the market off (it is off by default on test networks).

Tests

gateway/tests/test_trader.py: the score and its tags, the bar per archetype, the screen, a desk that calls on its own, the agent picking by number with names kept out, the fallback to the screen, calls followed to hits and misses, the no-repeat rule, the daily loss pause, the signing guard, and the API (only the dev arms a desk).