h100envy/crawl-hive: Memecoin safety swarm on Solana: Instant Crawl scans, Launch Radar, Narrative Radar, Clean Launch on pump.fun, user-owned crawlers, x402 for AI agents, $CRAWLHIVE buyback & burn.

Creator history. For pump.fun tokens the bonding curve account stores the creator's address. One getProgramAccounts call filtered by that address returns every curve the creator has made, with its graduated flag, so the scan knows the track record without any third-party API. Ten or more earlier launches with none graduated score as Serial launcher (−25); a weak record, a creator wallet under a day old or a creator still holding over 10% cost points too, and a creator whose launches often graduate earns a few. Example: a token whose creator had launched 28 others, none of which graduated.

Robinhood Chain. Paste a 0x… address (or a $TICKER with the Robinhood Chain toggle on) and the scan switches to EVM checks. Robinhood Chain has no mint or freeze authority, so crawler_holders checks what plays that role on EVM: whether the deployer still owns the contract (an owner can often change fees, pause trading or mint; renounced means nobody can), the holder count and top-10 share from GeckoTerminal, and GeckoTerminal's honeypot flag (you can buy but not sell, −60). Market, copycat tickers, Telegram and the X map work the same as on Solana. Wrapped ETH, USDG and bridged USDC are core assets.

Copycats are always younger. A token with the same ticker and a much bigger FDV only counts as "the original" if it listed no later than the scanned one. Fresh clones with inflated FDV (two $BONK copies with a ~$2B FDV appeared in 2025) no longer make the real token look like a copy.

Core assets. Wrapped SOL, USDC, USDT, JUP, JitoSOL and mSOL are recognised as core Solana assets: holder, copycat and bundle checks are skipped for them, since hundreds of tokens borrow their tickers.

Bundle detection. Pools and pump.fun curves are program accounts and are skipped; funders holding over 5,000 SOL are treated as exchanges, not links. Five or more linked top wallets (or 10%+ of supply) score as Bundled. Example: a 1-hour-old pump.fun token whose 12 top wallets were all created by one signer.

_{12 top wallets share one funder → Bundled. The X panel summarizes what call accounts and scanners post about the token.}

_{crawlhive.xyz: real crawlers only, no simulated network. (The octopus-spider crawls around the site; poke it.)}

_{The same map in demo mode (local runs): every dot is a crawler (colour = source, size = reputation), hexagons are the wallets that spawned them, dots flash when they fire a signal.}

The map sits on a honeycomb grid that pans and zooms with it. While the swarm is small, every crawler is labelled with its name, source and tier, every wallet with how many crawlers it runs, and the view zooms in so nothing gets lost; dashed links with a running spark show which wallet spawned which crawler.

How it works

flowchart LR
    A["👤 You<br/>sources + instructions"] -->|"pay in SOL or ETH<br/>30 days"| B["🕷 Crawler"]
    B -->|"crawls X · Telegram<br/>on-chain · docs"| S["🛡 Safety scan<br/>rugs blocked"]
    S --> C["⚡ Private signals"]
    C --> T["📬 My Signals<br/>& Telegram"]
    C -.->|"optional"| GB["🐙 Grok Bot<br/>look · watch · avoid"]
    C -->|"best price in your window"| E["⭐ Hit / miss<br/>Reputation"]
    E --> G["🏆 Leaderboard"]
    B -->|"renew any time"| B
    B -.->|"after token launch"| H["🛒 Marketplace · 🗳 Governance"]

1. Spawn. Choose a tier, a source, a chain (Solana, Robinhood Chain, Base, Ethereum), up to three narratives and your targets. Write your crawler's specification: plain-language instructions, keywords, filters, and what counts as a hit. Pay in SOL from Phantom, or in ETH on Robinhood Chain from MetaMask or Rabby. A payment buys 30 days of crawling.
2. Crawl. Your crawler sweeps its targets on a schedule: X through Grok search, public Telegram channels, DexScreener, or any web page. An AI reads what it finds through your instructions, and every token it picks out is safety-scanned before it becomes a signal.
3. Get your signals. Signals land in your private My Signals inbox and, if you connect the bot, in your Telegram DMs, with links to the source. Nobody else sees their content.
4. See who was right. Every signal with a token is tracked against the real price through your horizon: a hit if it reached your target, a miss if it did not. Precision, uptime, data volume and stake make up the crawler's reputation.
5. Renew. Three days before the term ends the bot reminds you. One click on the crawler page adds another 30 days; an expired crawler simply pauses until you renew.

Ready-made crawlers

Don't want to write a specification? The marketplace has nine crawlers with sources and rules we tested: Fresh Pair Hunter, Robinhood Chain Radar (new Robinhood Chain tokens from DexScreener), Boost Radar, AI Agent Scout (DexScreener), Pump.fun Buzz, Whales & Listings (Telegram), KOL Call Tracker (X via Grok), Ecosystem Watch and New Coins Lister (page changes). Buy is a regular on-chain spawn with the template's settings at the tier price; the slider icon opens Spawn prefilled so you can change anything first. Each card shows how many copies are running.

Narrative Hunter (new). An X crawler in narrative mode: turn on the narrative signal kind and, instead of looking for token calls, Grok searches X for what started spreading in the last 6 hours (memes, viral animals, AI launches, internet moments; tragedies, politics and self-promoting projects are skipped). Every post link Grok returns is checked with X's public oEmbed: an invented post (404) is dropped, a real one gets its real author, and a narrative with no real post never becomes a signal. Each signal also says how many coins with that ticker launched on DexScreener in the last 24 hours, so a fresh narrative and a squeezed one look different. Narratives carry no token, so they are not price-scored. Every narrative signal, in the feed and in Telegram, has a Launch this narrative button that opens Clean Launch with the name, ticker and description already filled in (src/lib/narrative.ts). Code: src/lib/server/crawl/sources/narratives.ts.

Narrative Radar (/narratives). The same hunt, run by the platform itself instead of a user's crawler: every NARR_RADAR_HOURS (1 on production) it searches X for Solana-friendly narratives, keeps the last 120 with a 12-hour ticker dedup, and shows them to everyone without delay. Each card has the heat (early, rising, hot), the kind, the verified posts, how many coins already launched on the ticker in 24 hours and a Launch this narrative button; once a coin with that ticker is launched through Clean Launch, the card links to it with its scan verdict. Narratives live over time: when a later hunt finds the same ticker within 48 hours it becomes a new sighting, which gives each card a stage (new, rising, peak, fading), a heat trail and the account that spotted it first. For three days the radar checks DexScreener for coins launched on the ticker after the narrative and keeps the best peak FDV it sees, then grades itself: the share of narratives older than a day that produced a $100k+ coin. Each card also carries the reach of its verified posts (views, likes, reposts, the biggest author) from the public fxtwitter API, the spread speed in views per hour, the post's picture, and a 0–100 Narrative Score that blends heat, reach, speed, a free ticker and the stage. Launch this narrative opens Clean Launch with the post's picture already in place, an on-demand Generate art button (grok-imagine-image, about $0.02, cached per narrative, NARR_ART_DAILY per day) and a 1500×500 DexScreener banner drawn in the browser. The bot answers /narratives with the latest finds. NARR_RADAR_OFF=1 turns it off. Code: src/lib/server/narrative-radar.ts, src/app/narratives/page.tsx.

Your crawler, your rules

Every crawler you spawn gets a specification: what it should look for, written in plain language, plus filters and a scoring rule. An AI (Grok) reads every new post, message, token or page through those rules and only sends you what fits.

_{Writing the specification while spawning: instructions, keywords, signal types, minimum confidence, on-chain filters and what counts as a hit.}

Signals are yours alone. They land in My Signals with links to the source and the safety verdict, and each one that points at a token is tracked against the real price through your horizon: a hit if it reached your target, a miss if it did not. Other users only see that your crawler fired.

_{My Signals: a real on-chain crawler's output. 10 signals scored against DexScreener prices 15 minutes later, 5 hits.}

_{A live crawler's page as its owner sees it: crawl status, editable specification, reputation breakdown, private signals.}

Under the hood, every signal is checked before it reaches you:

• Safety gate. Each token a crawler finds on Solana or Robinhood Chain goes through the Instant Crawl scan first (market, holders, bundles, creator history, honeypot and owner on Robinhood). DANGER never reaches you; every other signal carries its verdict and a link to the full scan. The most confident finds are checked first; whatever does not fit into a run's scan budget waits for the next run instead of going out unchecked. If a scan fails, the signal waits one run; only a second failure in a row lets it through without a verdict.
• Fair scoring. The price is sampled every 5 minutes while a signal is in its window. A hit means the token reached your target at any point in the window, not only at the last minute, and every scored signal shows its peak and drawdown.
• Smarter repeats. Duplicates are muted per token and signal type, so a whale buy after a new-pair alert still gets through.
• Backoff. When a source keeps failing, each next try waits twice as long, up to an hour, instead of hammering it.
• RPC limiter. All Solana RPC calls share one rate limiter with retries on 429, so a rush of scans no longer starves the checks.

$CRAWLHIVE: buyback & burn

• Buyback & burn. The treasury that collects spawn payments buys $CRAWLHIVE every 12 hours. One transaction does both: a Jupiter swap SOL → $CRAWLHIVE (routes through the pump.fun curve too) and an SPL BurnChecked of the guaranteed minimum output, plus a crawlhive:buyback memo. The transaction is built by the server but signed by the treasury wallet in Phantom: the server never holds the treasury key, and only a signed-in treasury session can request one. After it lands, the server reads it from the chain (success, signer, burn of the mint, SOL spent, tokens burned) and adds it to the public list. Leftover dust above the minimum can be burned with one more click. The team gets a Telegram reminder when each 12-hour window opens.
• x402 revenue goes into burns too. AI agents pay for scans in USDC straight to the treasury's USDC account; spawns and renewals pay in SOL with their own memos, so the sources never mix onchain. The buyback card shows revenue by source (spawns, x402 calls, DEX fund) with a Solscan link for every x402 settlement. In the same 12-hour cycle the treasury can buy back with USDC: a Jupiter swap USDC → $CRAWLHIVE plus BurnChecked and a crawlhive:buyback:x402 memo, recorded with the USDC spent as its own line.
• Contract: D4jNDQa3Cu4v8VMCAc2z7pgGGo7aGqzjXmwGR9wapump (Token-2022, launched on pump.fun). In Telegram /token (or /ca) shows it with buy and chart buttons.
• Config: TOKEN_MINT / TOKEN_SYMBOL turn on the token block, buybacks and the holder check. Code: src/lib/server/buyback-tx.ts, buyback.ts, src/components/token-panel.tsx, buyback-burn.tsx.

DEX fund

Under buyback & burn on the home page (and from the 🚀 buttons in the menu and the hero) anyone with Phantom can chip in 0.05–1 SOL, or pay the whole current level at once, toward $CRAWLHIVE on DexScreener. The fund climbs a ladder: DEX paid (Enhanced Token Info, $299), then Boost 10x ($99), Boost 30x ($249), Boost 100x ($899) and the Golden ticker (500x, $3,999); prices are DexScreener's as of October 2026 and can be changed with DEX_LEVELS. A level paid outside the fund can be listed in DEX_PAID_ELSEWHERE: it then shows as paid and its price is not taken out of the gifts, so donations go to the next level. The server builds one transaction (a SOL transfer to the treasury plus a crawlhive:dexfund memo), Phantom signs and sends it, and the gift is counted only after the server finds the transfer onchain. Raised SOL is held apart from buybacks; a level counts as spent once DexScreener's public orders API shows it bought, and the fund moves on to the next level, so the button never disappears. Code: src/lib/server/dexfund.ts, src/components/dex-fund.tsx.

Contract X-Ray

Closed-source contracts are where the traps hide, so the scanner reads the code itself.

• EVM (BNB Chain, Robinhood Chain). eth_getCode, then a proper opcode walk (push data skipped, metadata tail cut) collects the function selectors from the dispatcher. They are matched against 134 dangerous signatures (selectors computed with keccak at load, none typed by hand) grouped into powers: Can mint, Can blacklist, Tax can change, Can seize balances, Can stop trading, Sell limits, plus low-weight launch mechanics (enable trading, remove limits, tax-free wallets). EIP-1967, beacon, EIP-1167 and legacy OpenZeppelin proxies are detected and the implementation is read too: an upgradeable contract is flagged Upgradeable, with the admin. SELFDESTRUCT is flagged. If ownership is renounced and no role-based access (grantRole, authorize) exists, owner-only powers are shown as dead and don't count. Unknown functions are counted, never guessed.
• Behaviour, not just names (evmole, the EVM engine inside REA). Scammers rename their functions, so a name table alone misses them. The bytecode also goes through evmole (MIT, WASM, about 30–500 ms per contract), the engine that the REA "reverse engineer anything" toolkit uses for EVM: it recovers every function with its argument types and mutability, plus the storage layout, meaning which functions read and which write each slot. From that the scanner infers levers the name table can't see: an unrecognised function that sets a per-wallet flag every transfer checks, a setter for a number every transfer reads (tax, limit, threshold), a function outside the known mint/burn that writes the total supply. Candidate names are looked up in the open signature database (openchain): a pool list (setAutomatedMarketMakerPair) is told apart from a block list, initializers are skipped, and a function named like a standard ERC-20 call with different arguments (Approve(address[])) is flagged as a Disguised function, a classic honeypot trick. Inferred findings say so, and an unnamed flag is only reported as a possible hidden blacklist. We use REA's engine rather than REA itself: its website module needs a full Chrome executing the site's code on the server, which bypasses our SSRF guard and costs about 1.5 GB of RAM per scan.
• Solana. Classic SPL tokens have nothing to read beyond mint and freeze authority. Token-2022 mints are unpacked: Permanent delegate (one wallet can move or burn anyone's tokens), Transfer hook (the team's own program runs on every transfer, and can block sells), Transfer tax with its current rate and whether the authority can change it, New wallets start frozen, Can pause all transfers, Can't be transferred, confidential transfers.
• Project website. The site listed on DexScreener is fetched through the SSRF-safe fetcher (page plus up to 8 scripts, analytics skipped) and checked for drainer behaviour: unlimited approvals to a hard-coded spender, Permit2 / Seaport order signing, Solana signAllTransactions with transfers to a hard-coded address, known drainer kits and Telegram-bot loggers, heavy obfuscation next to wallet code. Scripts are parsed into a syntax tree with @babel/parser (the same parser REA uses for JavaScript), never executed: the check looks for an actual approve / increaseAllowance call with an unlimited amount, a setApprovalForAll(…, true), a wagmi-style writeContract({ functionName: "approve", args: [...] }), raw 0x095ea7b3 approve calldata, or a Solana SystemProgram.transfer / createTransfer…Instruction / createSetAuthorityInstruction, where the spender or recipient is a hard-coded address (followed through const SPENDER = "0x…" and new PublicKey("…")). Known routers (Uniswap, PancakeSwap, 1inch, 0x, Permit2, Seaport) don't count. A string in a library ABI next to an unrelated address no longer looks like a drainer. Files too large or broken to parse fall back to pattern rules, and obfuscated bundles keep their own rule. The rules need several signals together and were tuned on real sites (pump.fun, Uniswap, Raydium, Jupiter, OpenSea, meme sites) so that legitimate dapps don't fire.

Clean Launch

crawlhive.xyz/launch launches a coin on pump.fun from CrawlHive: name, ticker, picture, description, links and an optional dev buy (up to 5 SOL) in the same transaction.

• The mint key is made in the browser. Only its public half reaches the server.
• The server builds, Phantom signs, the server sends only a byte-for-byte match. The picture and metadata go to IPFS, the server builds pump.fun's create_v2 (plus the creator's first buy) with a public address lookup table so the launch fits one transaction, the mint co-signs in the browser and the creator signs in Phantom. If anything in the signed message differs from what was built, nothing is sent.
• No key on the server, 0% platform fee. pump.fun's creator fees go to the creator's wallet as usual.
• Scanned at birth, same rules. A few seconds after a coin goes live the swarm scans it like any other; the verdict is shown next to the launch and recorded on the Track Record. Coins launched here get no score boost.
• Config: PINATA_JWT (IPFS) switches launches on; LAUNCH_TABLE, LAUNCHES_PER_IP_HOUR, LAUNCHES_PER_DAY, LAUNCHPAD_PAUSED. Code: src/lib/server/launch.ts, src/app/launch/page.tsx.

Track Record and Launch Radar

Track Record (/track) answers the only question that matters about a scanner: did the verdict come true? Every verdict is stored with the price and liquidity at the moment of the scan, whether it came from a user scan, a crawler's safety check, Launch Radar or an agent through MCP. For the next 24 hours the price is sampled every 10 minutes. A token counts as dumped when its low falls 50% below the scan price, and as rugged when its liquidity drops below 20% of the start or the pair disappears. One token counts once per day, and a real verdict replaces an earlier TOO_EARLY. The page splits the outcome by verdict, lists the DANGER calls that came true (We warned you) and the CLEAN / OK calls that dumped anyway (We missed), and shows the hit rate of crawler signals without revealing their tickers.

Launch Radar (/radar) is the swarm scanning on its own. Every 3 minutes it takes new DexScreener profiles and boosts on Solana, Robinhood Chain and BNB Chain, keeps launches between 36 minutes and 24 hours old with at least $5k liquidity, and runs the full Instant Crawl scan on up to four of them (no X search, so no Grok cost; 500 scans a day at most). Everyone sees the verdicts 10 minutes later; crawler owners get finds like these the second they appear, filtered to their own rules. The page shows a live radar screen (rotating sweep, one blip per launch, newest at the center, tap a blip to jump to its card) and cards with the token logo, FDV and liquidity at scan, score and verdict, a copyable contract, chain and verdict filters.

Onchain proof: a track record that can't be edited

Every 15 minutes all new verdicts and crawler signals are hashed into a Merkle tree, and its root is written to Solana in a Memo transaction signed by one public notary wallet. Once a root is onchain, no record in that window can be changed or deleted after the price moves: the root would stop matching. Anyone can check a record on /track: find it by token address or signal id, and the browser recomputes the leaf and the path with WebCrypto and reads the memo straight from a public Solana RPC, so you don't have to trust our server.

| Piece | Format (v1) | | --- | --- | | Leaf | sha256(0x00 ‖ record JSON with sorted keys) | | Node | sha256(0x01 ‖ left ‖ right), an unpaired last node moves up as is | | Memo | crawlhive:proof:v1::: | | API | GET /api/proof (latest roots), ?q= (record, path, transaction), ?batch= (every leaf of a window) |

Private crawler signals are committed as a salted hash of their content, so their tokens stay hidden until the owner reveals them. What the proof does not show: that a record was never left out before its window closed. Code: src/lib/server/proof.ts, src/components/proof-card.tsx.

Signals in Telegram

Open My Signals, press Connect Telegram and hit Start in the bot chat. The site gives you a one-time link (valid 15 minutes) that ties your wallet to that chat; nothing else is shared. From then on every new signal from your crawlers arrives as a DM with the ticker, contract address, confidence, source links and a link back to the crawler. /status shows linked wallets, /stop unlinks.

CrawlHive app in Telegram (Mini App). The bot's menu button opens a full app at /tg, built for a phone, with five tabs: Scan (paste or one tap from the clipboard, live crawler log, score ring, every flag with its weight, Watch / Share / Full report), Radar (fresh launches the swarm scanned), Watch (watchlist with the live price since you started, Launch Radar alert filters, 24-hour follow-ups), Crawlers (your crawlers and their private signals, Jev ratings, Grok Bot takes and outcomes, once your wallet is linked to Telegram) and Track. The user is identified by Telegram's signed initData, checked on the server on every request (HMAC with the bot token, 24 hours max), so there is no sign-up. The app and the bot share the watchlist and settings. It follows Telegram's theme, vibrates on a verdict and uses Telegram's back button. Illustrations were made for the app with Higgsfield.

@crawlhivebot in chats and groups, wallet or not:

| Feature | How it works | |---|---| | Scan in the chat | Send a Solana mint, a Robinhood Chain 0x… address, a pump.fun / DexScreener / GeckoTerminal link or a $TICKER. The reply is the scan card image with the verdict, the main flags, a ⚡ Jev take (LOOK / WATCH / AVOID with its confidence) and buttons: Full scan, Watch, Chart, Rescan. A $TICKER is looked up on Solana first, with one tap to search Robinhood Chain. 10 scans an hour per chat. | | Groups | Add the bot to a group and it answers every contract address posted there with a short verdict as a reply. The same token is answered once per 30 minutes, 20 scans an hour per group; only group admins can change the settings or turn it off with /autoscan off. | | Watchlist | 👁 Watch keeps an eye on a token for 7 days: one ping if the pair disappears, liquidity falls below 30% or the price drops 50%, and a rescan every 3 hours to tell you when the verdict turns DANGER. Up to 5 tokens per chat. | | 24-hour follow-up | A day after your scan the bot comes back with the outcome from the Track Record: we called it, it held, or we missed this one. Up to 3 a day, /followups off to stop. | | Launch Radar alerts | /alerts: fresh launches with filters (Clean / OK only or all verdicts, minimum liquidity $5k / $25k / $100k), up to 25 a day. Chats linked to a wallet with a live crawler get them live, everyone else after the 10-minute delay. | | Inline | @crawlhivebot