Robicop has read every block Robinhood Chain has ever mined. We tag the wallets that rug, extract and clip, and hand the list to your trading agent before it buys.
Every tag is a behaviour with a threshold fitted to this chain. Each one carries the transaction that proves it.
Drains ≥80% of a coin’s curve inside 25 blocks — about five seconds. Solo dev or swarm.
One actor, several addresses — first buys landing within 8 blocks of each other, again and again.
In cheap and early, out at profit onto the buyers behind it, across rugged coins.
One sell that takes ≥25% of a coin’s curve — craters the chart at any market cap. A trait, not a crime.
Robicop reads the entire chain, block by block, around the clock. Every coin, every wallet, every trade — nothing is sampled, nothing is skipped.
A rug has a shape: a coin’s money drained in about a second, with real buyers left holding it. We measure that shape directly — so it means the same thing on a tiny coin as on a big one.
Panic sellers, routine liquidity moves, normal launch behaviour — all filtered out before anyone is named. Losing money in a rug makes you a victim, never a suspect.
One bad exit could be luck, so it earns a watch — not a badge. The same wallet doing it again on another coin gets booked, and every single claim links to the exact transaction on the public explorer.
This view is served from a cached snapshot so it stays free and fast under load. Our collectors classify wallets as blocks mine — roughly 4.95 blocks a second — and holders get that stream unmetered. See ranks →
Wallets — alone or as a swarm — that drained a coin’s curve, on more than one coin. Repetition is the claim; one exit is never enough.
Wallets among the first 25 buyers of a coin who then sold into its drain. Early entry plus a hand in the exit.
Sells that took a quarter or more of a coin’s curve in one transaction — the kind that crater a chart, at any market cap. A behaviour, not an accusation; the count and the receipts are shown.
Addresses whose first buys keep landing within eight blocks of each other, coin after coin. They move together.
Robinhood opened trading to agents over MCP — 70,000+ agentic accounts across Claude, ChatGPT, Cursor and Grok. Robicop speaks the same protocol, so your agent checks a coin before it trades it.
Account data, market feeds and order placement over agent.robinhood.com/mcp/trading — around 50 tools.
Sandboxed accounts, spending limits, manual approvals. They control how much an agent can lose — not who it trades against.
> check_coin("0xeb576c467d69e084…")
VERDICT avoid
reason 2 booked ruggers sold this pool
──────────────────────────────────────────
rugger 0xcaf681a6… 2 coins
rugger 0xef6869e7… 2 coins
──────────────────────────────────────────
proof /tx/0xb376fa637859a675…The patrol and the live MCP layer are free for everyone. The historic database is for holders of at least 500,000 $ROBICOP — batches unlock as your holding time climbs, read from the chain, not your browser.
Connect an EVM wallet on Robinhood Chain (4663) to check your rank.
A wallet-intelligence layer for Robinhood Chain, built for autonomous trading agents. This is the complete method — the data plane, the maths, and the rules every claim has to survive.
A trading agent evaluating a token sees a price, a pool and a clock. It cannot see that four of the top holders are the same person, that the wallet that just added liquidity has drained six pools this week, or that the buyer ahead of it has sold into a collapse on every coin it has ever touched.
That information exists — it is in the chain's own history — but it is not available at the speed or shape a decision needs. Robicop reads the entire chain continuously, resolves behaviour into a small set of evidenced classes, and exposes the result as a single call an agent makes before it commits capital.
The whole chain — bonding curve through migration and beyond. Every class is proportional to the market it hit, so the same rule means the same thing at a 7k market cap and at 7M.
Read-only. Robicop returns a verdict and its evidence. It never places an order, never requests an approval, never holds a key.
Most indexers listen to one. Both are required, because each is silent about something the other hears.
The sequencer broadcasting transactions as it orders them. Push, unauthenticated, no rate limit.
Delivers intent and ordering: signed transactions and calldata, at sequencing time, before execution. Carries a monotonic sequence number.
eth_getLogs over a moving cursor against a provider pool.
Delivers outcome: emitted events, amounts, resulting prices. Cannot see a reverted transaction, because a revert writes no logs.
Everything else is parallel. RPC capacity is the hard ceiling on how fast history closes and how tight the live edge sits, so it is treated as a managed budget rather than a dependency.
Dedicated paid endpoints for range reads, where eth_getLogs windows run to thousands of blocks. Free tiers are reserved for point queries — several cap ranges at ten blocks, which is slower than the public node for backfill and faster for single lookups.
Each endpoint has a job: range reads, point reads, or standby. Rotating blindly across providers means every worker rediscovers the same limit independently, and each rediscovery looks like missing data.
Workers draw from one pacer per endpoint rather than backing off individually, so the fleet converges on the provider's real capacity instead of oscillating around it.
A range doubles while results stay under the log ceiling and halves on a cap error. Log density varies by orders of magnitude across a chain's life, so a fixed window is wrong everywhere except one place.
Failure taxonomy. Not every failure is missing data, and treating them alike corrupts the coverage record:
429 / rate limited -> slow down, retry never a gap
5xx / non-JSON body -> provider unhealthy never a gap
range cap exceeded -> halve window, retry same never a gap
timeout -> retry with backoff gap only after budget
empty result -> genuinely no logs coverage, not absenceA range is recorded as missing only after a transient budget is exhausted — nine attempts with backoff to sixty seconds. The live tail always holds priority; backfill yields to it, because currency cannot be recovered later and completeness can.
The archive is append-only object storage. Chunks are named by the block range that was requested and answered, and are written even when a range legitimately returns nothing.
chain-rh/logs/000051302535-000051302734.jsonl.gz
└──────┬─────┘ └──────┬─────┘
from to
coverage = union of every name
holes = the complement of that unionThis makes coverage a set operation on filenames rather than a number a process maintains. Counters reset on restart, double-count retries, and drift from reality silently. Names cannot: an object exists precisely because that range was fetched and stored.
Sequence numbers from the feed give the same guarantee on the live edge. They are monotonic and gapless by construction, so a dropped socket is arithmetic rather than a mystery — hold 51,579,398 and 51,579,400 without 399 and the missing range is known exactly, immediately, and can be refetched.
Every concentrated-liquidity swap log carries sqrtPriceX96, liquidity and tick. The obvious move is to reconstruct price and compare. It fails silently at exactly the scale this product operates at.
a coin worth ~1e-9 in the quote asset
sqrtPriceX96 / 2^96 -> ~1e-13
( … )^2 -> ~1e-26
double precision is exhausted; unrelated prices
collapse toward zero and every comparison reports
a total loss.A tick is an exact integer with price = 1.0001^tick. A proportional move is therefore a fixed tick delta at every scale, for every decimals configuration, with no precision loss:
Δtick = ln(ratio) / ln(1.0001)
−90% → −23,026 ticks
−95% → −29,957 ticks
−99% → −46,052 ticksBecause a collapse is a ratio, detection needs no fiat feed at all. Quote-denominated price comes from the chain; a single reference rate converts it for display only, and never enters a threshold. A price layer that can be disagreed with is a price layer that can move a verdict.
Robicop's universe is launchpad coins with a bonding curve and a migration path. Provenance is a property of the token record, not a filter applied at query time — a token without a resolved launchpad never gets a row.
A risk classifier has false negatives, and a false negative costs a user money. Provenance is deterministic: a token either was created by a registered launchpad or it was not.
The gate collapses the candidate set by orders of magnitude before any expensive computation runs, which is what makes full-history classification tractable at all.
Contracts outside that universe are still read — liquidity events are tracked chain-wide, since a pool can be drained anywhere — but they never produce a wallet class.
"Did price fall 90% within W blocks" is a property of every window in a series. Measuring peak-to-trough instead answers a different question — all-time high to all-time low — and is slow by construction, which hides exactly the events that matter.
Across a sampled cross-section of the chain the distribution separates cleanly:
fall of >=90% inside W blocks, by window
W = 5 (~1s) engineered exit
W = 25 (~5s) "
W = 50 (~10s) ── flat ──
W = 250 (~50s) ── flat ──
W = 5000 (~17m) ordinary declineNothing occurs between ten and fifty seconds. That flat interval is a real structural boundary between two different phenomena — an engineered exit and an ordinary decline — and it is why the window is 5 blocks. The threshold is read off the distribution rather than chosen, which means it can be re-derived by anyone with the same data.
A pool that collapses because holders sold and a pool that collapses because liquidity was withdrawn look identical on a price series. Only one has a culprit, and conflating them is the single most common way a scanner publishes false accusations.
Token moves into the pool, quote moves out. The sending address is a seller, and appears in the candle's cohort.
Burn, or a negative liquidity delta. A provider withdrawing. Recorded as its own event class; no wallet is tagged.
Account abstraction. ERC-4337 is live on this chain, so the transaction sender is frequently a bundler rather than the trader. Actor identity resolves through UserOperationEvent.sender. An indexer that reads tx.from attributes thousands of unrelated trades to a handful of bundler addresses, and nothing in its output reveals the error.
Causal window. Only the opening blocks of a collapse carry causation. Wallets selling several blocks later are reacting to the move, not creating it, and are excluded from the cohort by design.
Every class carries a measured base rate — how often ordinary wallets do the same thing. Without one, a detector simply flags the whole chain, because most predatory-looking behaviour is also ordinary behaviour.
Sold into a ≥90% collapse inside 5 blocks, on more than one coin. Cohort limited to the causal blocks; liquidity pulls excluded before any wallet is considered.
One actor across several addresses — first buys landing within a tight block window, repeatedly, across coins. A structural link: they move together. Intent is not claimed.
Enters cheap and early, exits at profit onto the buyers behind it, repeatedly across coins that later collapse. Requires the market-cap layer.
A single sell taking ≥25% of the coin’s curve reserve — proportional, so it means the same crater at every market cap. Descriptive: shipped as a count, never as a verdict.
Robinhood exposes trading to agents over the Model Context Protocol. Robicop speaks the same protocol, so it installs beside the trading server and becomes available as tools the agent can call mid-decision.
check_coin(ca) verdict + booked wallets currently holding
check_wallet(addr) every class on an address, with proofs
watch_launches() new bonding-curve launches, pre-filtered
export(batch) the wallet list, by access rankClassification output is published as an immutable artifact; the API and MCP server read that artifact. No request path reaches the archive, so response latency is independent of ingestion load and a traffic spike cannot slow collection.
A cached snapshot, served free. Recent window, full evidence, rate limited.
Classification as blocks mine, unmetered, with the database released in batches earned by holding tenure read from chain.
Not the wallet page — the exact event, on the public explorer. A claim without a transaction behind it does not ship.
Each tag stores the query that produced it. Re-run it and the tag survives or is deleted. No claim outlives its evidence.
We describe what an address did on chain. We do not assert who controls it or why.
A verdict is returned. Nothing is signed, approved, ordered or custodied.