ethduke/robinhood-contract-traps

Robinhood Chain Contract Traps

Owner powers and honeypot logic of token contracts, answered from bytecode — including the ~95% of contracts whose source was never published. Every token launched on Robinhood Chain (chain id 4663) from 2026-05-22 to 2026-10-02, its decompiled runtime code, yes/no answers to trap questions, and whether the liquidity was pulled within 24 hours, plus what happened in each launch's first hour (early trading, developer holdings, who holds the liquidity). Built to train and evaluate small, cheap classifiers (Tev-style: code + question + lettered options → one letter) and to give agents a lookup index of known trap code.

Defensive risk triage only. Not investment advice; a "no" is not a safety guarantee.

What is in it

config	one row per	rows	what
instruct (default)	question	90,333	Tev-style rows: skeleton → code in decompiled, question, options (A yes / B no), answer; split by code shape
labels	contract code	519,489	7 owner-power answers + sell_block, overall, fee_cap, summary, evidence, label source, simulation result of the code shape (sim_stage, sim_honeypot)
decompiled	contract code	523,800	compact heimdall decompile (names resolved, common bodies folded), function fingerprints, shape id
functions	function body	193,760	code-lineage index: selector, resolved signature, how many contracts use it, trap keys if known
tokens	token	1,259,484	launch pool, launchpad, proxy facts, code/skeleton/shape ids, 24 h outcome
warmup_mainnet	contract code	19,997	Ethereum mainnet tokens, same view and rules + Slither detectors (training only)
instruct_warmup	question	189,606	warm-up questions (7 owner powers + 5 Slither detectors)
launch_behavior	launch × snapshot	3,284,787	early-swap features at +1 / +10 / +60 min for every launch (1.09M), leakage-safe pull label
launch_holders	launch × snapshot	588,801	last 30 days (196k launches): creation receipt, developer balance / selling / hand-outs, LP custody
early_buyers	buy	251,030	last 14 days: the first 8 buys of each launch with the real wallet (transaction sender)
launch_crowd	launch × snapshot	1,301,069	443k launches (v2 / v3 all history, v4 from 2026-08-25): buyer-crowd history — wallet farms that took part in earlier dumps
honeypot_sim	code shape	4,685	one live token per code shape bought from its pool and sold 5 minutes later through a router-style path (simulated, nothing sent on chain): stage reached, taxes, revert reason, sim_honeypot

Questions

key	question
block_wallets	Can the owner make transfers revert for specific chosen addresses (blacklist, bot list, frozen accounts)?
trading_switch	Can the owner stop trading for everyone who is not exempt?
limit_tx	Can the owner set or change a max transaction, max wallet or cooldown after deployment?
change_fees	Can the owner change the buy, sell or transfer fee after deployment?
owner_mint_or_balance_edit	Can the owner mint new supply or edit other holders' balances?
owner_withdraw	Can the owner withdraw ETH or tokens held by the contract?
tx_origin_in_transfer	Does the transfer logic depend on tx.origin?
sell_block	Can sells fail or be taxed at 50%+ for normal holders while buys still work (honeypot)? (teacher only)
external_control	Can another contract decide whether transfers succeed (every transfer checks or calls an outside contract that can block it)? (teacher + code rule)
fake_events	Does the contract emit Transfer events that do not match real balance changes? (teacher only)
lp_pulled_24h	Launched in a pool with this code, was the liquidity pulled within 24 hours? (on-chain outcome)
sells_fail_sim	Bought from its pool and sold five minutes later through a router, does the sell fail or lose more than half? (simulation)

Owner powers mean powers that remain after launch: one-time settings (initializers, a pool or launch block that can be set once, trading that can only be opened) do not count.

How the labels were made (cheapest first)

source	contracts	how
rules	23,462	Slither-based source-logic rules on Sourcify-verified code (owner-set state checked where a transfer can revert, owner-set numbers in the fee math, owner functions changing balances and supply, …)
lineage_exact	156,456	unverified code whose set of decompiled function bodies equals a rule-labelled contract
lineage_surface	2,239	same transfer path and same owner-only function bodies as a trap contract (positive keys only)
teacher_glm53 / teacher_sonnet	1,020	an LLM read the blind compact decompile and answered the rubric with evidence (GLM-5.3; Claude Sonnet 5.5 for part of the set)
shape_*	335,744	copied inside a code shape (same code, large constants and selectors ignored) — only answers all labelled members agree on
rule_extcall	568 (+1,568 external-control positives in all)	decompiled-code rule: transfer passes the sender or recipient to a non-DEX function of another contract; positive only (precision 0.89, recall 0.57 against the teacher)

Checks: on blind verified controls the teachers agree with the rules on 23–30 of 30 per question (GLM-5.3 and Sonnet 5.5 give the same answer on 322 of 330); most disagreements are rule weaknesses the teacher gets right (exemption lists, one-way switches, tax-wallet withdrawals). Rule labels agree inside 868 of 870 code shapes.

Splits

By code shape (9,074 shapes): no shape appears in two splits, so re-deployments of one template never leak from train to test. Valid and test are the newest shapes (cut-offs at the 80th/90th percentile of first-seen block over labelled shapes). warmup_mainnet / instruct_warmup are training data only.

from datasets import load_dataset
q = load_dataset("ethduke/robinhood-contract-traps", "instruct", split="train").to_polars()
code = load_dataset("ethduke/robinhood-contract-traps", "decompiled", split="train").to_polars()
rows = q.join(code.select("skeleton", "code"), on="skeleton")
prompt = rows[0, "code"] + "\n\n" + rows[0, "question"] + "\n" + rows[0, "options"] + "\nAnswer:"

Honeypot simulation

Code labels say what an owner can do; the simulation shows what happens now. For one live token per code shape (4,685 shapes covering 1.23M of 1.26M tokens), a simulator contract is injected into an eth_simulateV1 call by a state override (nothing is deployed or sent): block 1 buys 0.01 ETH of the token from its own pool (v2 / v3 / v4) into a wallet, the wallet approves the simulator and 1% is moved with transferFrom (transfer-tax probe); block 2, five minutes later, the simulator pulls the rest with transferFrom and sells it — the path a router takes for a user.

outcome	code shapes
bought and sold normally	3,419
honeypot (sell or transferFrom reverts with no transfer tax, or the round trip loses > 50%)	368 (10,099 tokens)
could not buy (pool rules, hooks, fees)	576
no liquidity left in the pool	404

Most honeypot sells revert without a reason; named ones include "ETH transfer failed" (the token's own sell-side swap reverts), "please wait" (a permanent block on transfers to the pool, despite the wording) and v3 "IIA" (a sell tax the pool cannot accept). Against the code labels, on 332 shapes that have both: code labels flagged 11 of the 46 simulated honeypots (24%) and 21 shapes they flagged sold normally — the simulation adds objective labels exactly where code reading is weakest. Limits: the simulation runs at the current block (traps not switched on yet are not seen, rugged pools cannot be tested) and uses one token per shape (shape members share code, not state).

Launch behaviour and rug risk

Four tables describe each launch at snapshots +1, +10 and +60 minutes after its pool was created. Each row uses only what had happened by its snap_block. Labels, all "after the snapshot and within 24 h of launch": lp_pulled_after (liquidity fell to ≤ 20% of its peak), dumped_after (price fell to ≤ 10% of its running peak within 15 minutes of being ≥ 50% of it, and was still ≤ 20% of the peak at 24 h — wallet farms or insiders selling into a pool whose liquidity cannot be pulled), and rugged_after = either. Use eligible with the pull label and eligible_rug with the dump / rug labels (they are false when that had already happened by the snapshot).

snapshot	eligible launches	pulled after	dumped after	dumped without a pull	rugged after
+1 min	1,093,119	13.5%	3.4%	2.4%	15.9%
+10 min	998,577	6.9%	1.8%	1.0%	7.9%
+60 min	942,093	2.2%	0.3%	0.2%	2.4%

• launch_behavior (all launches 2026-05-22 → 2026-10-01, from swap logs only): swaps, buys, sells, ETH in and out, price change and drawdown, first-block buys, share of buy volume in one block / one transaction / the pool-creation transaction, buys per transaction, same-amount fan-outs, buyer concentration (v2 / v3; v4 swap logs name only the router, so wallet columns are null there), ETH in the pool at +1 min.
• launch_holders (launches 2026-09-01 → 2026-10-01): developer = sender of the pool-creation transaction (the smart account for ERC-4337 launches); dev_alloc_share = tokens the developer received in that transaction; creation_recipients = other wallets that received the token in it (pool, launchpads, lockers, burn addresses excluded); developer balance at the snapshot (dev_share, seeded with the balance before the pool block), peak, share sold (dev_sold_frac; moving tokens into the pool as liquidity is not a sale), wallets the developer handed tokens to; lp_holder_class of the largest LP holder: burned, locker, launchpad (hook, factory or launchpad contract), eoa, contract, none_found (no LP token or position, e.g. pairs with internal liquidity).
• early_buyers (launches 2026-09-17 → 2026-10-01): buyer = transaction sender of each of the first 8 buys.
• launch_crowd (v2 / v3 launches, all history; v4 launches from 2026-08-25; buyer = swap recipient with routers removed, or for v4 the wallet that received the token from the PoolManager in the buy transaction): compares the launch's buyers so far with early buyers of launches in the previous 7 days, using only outcomes already known at the snapshot. crowd_dumper_share = share of buy volume from wallets that took part in ≥ 2 earlier pure dumps; crowd_hist_rug_rate = how often the earlier launches these wallets bought were rugged; crowd_overlap_frac = share of buyers who also bought one single earlier launch (a crowd moving together); crowd_bot_share = volume from wallets that buy nearly every launch (> 300 in the span). Example: a token launched 2026-09-27 with burned liquidity was dumped −98% 2.4 h after launch by 353 wallets funnelling their tokens into one seller; at +10 min, 99.97% of its buy volume already came from wallets with ≥ 2 earlier dumps.

Rug rate (+10 min, eligible launches of the last 30 days, 13% overall): LP held by a plain wallet 42% (vs 0–2.5% for burned / locker / launchpad / contract custody); developer still holding > 50% of supply 36%; creation transaction sending the token to ≥ 5 other wallets 45%.

How much each kind of check predicts a rug — pull or dump — within 24 h (gradient-boosted trees; trained on the oldest 75% of the last 30 days' launches, tested on the newest 25%; recall at a cut-off giving 5% false alarms):

snapshot	inputs	test launches	rug rate	AUROC	avg precision	recall @ 5% false alarms
+1 min	code only	51,729	29.3%	0.891	0.871	81.5%
+1 min	+ light launch facts	51,729	29.3%	0.971	0.946	87.4%
+1 min	+ full early trading	51,729	29.3%	0.980	0.957	87.9%
+10 min	code only	41,358	11.5%	0.910	0.777	66.5%
+10 min	+ light launch facts	41,358	11.5%	0.985	0.917	91.3%
+10 min	+ full early trading	41,358	11.5%	0.987	0.930	90.0%
+60 min	code only	38,360	4.6%	0.892	0.404	33.2%
+60 min	+ light launch facts	38,360	4.6%	0.976	0.689	82.0%
+60 min	+ full early trading	38,360	4.6%	0.981	0.733	83.8%

code only = code answers (labels above) + how often launches with the same code shape were pulled earlier; light = + launchpad, DEX version, starting ETH, creation receipt, LP custody, developer share; full = + early swaps, developer selling and hand-outs, first buyers, buyer crowd. At +10 min the full model flags about 80% of the test period's dumps without a pull at the same 5% false-alarm cut-off. Buyer-crowd features add little to these scores on top of the other launch facts (v4 launches: AUROC 0.970 with or without); their value is explaining a flag (e.g. "buyers' earlier launches were 91% rugged").

Numbers worth knowing

• 1.26M tokens, all with runtime code analysed (clones and proxies unwrapped); 526k distinct code skeletons → 9,074 shapes; 981k tokens (78%) have code labels.
• 1.09M launches with an outcome (launches up to 2026-10-01); 13.5% had their liquidity pulled within 24 h.
• Traps are rare overall (~3% of codes) and concentrated in one-off contracts: in a random sample of 300 one-offs, 45% of rugged vs 25% of kept tokens had a harmful owner power (teacher labels).
• Code similarity carries the signal: one-offs sharing ≥70% of their function bodies with a known harmful contract were harmful in 83% of cases (vs 38% at 30–50% overlap; teacher labels, 81 contracts).

Fresh-token check (contracts deployed after the labelled data)

Of 28.7k tokens launched 2026-09-29 to 2026-10-02, 56% had exactly known code and 18% a known code shape, so the dataset answers 74% of new tokens by lookup alone. On 60 brand-new contracts (labelled blind by the teacher) most code was clean (42 clean, 7 standard controls, 10 risky, 1 malicious); 9 of the risky ones gate every transfer through an external contract, now covered by the external_control question.

Limitations

• Decompiled code is lossy: some bodies are stubbed or garbled; teacher answers on such code are inferences.
• Rules miss owner checks hidden behind hardcoded addresses or tax wallets, and count some exemption lists as blacklists; warm-up block_wallets / limit_tx are noisier for this reason.
• Teacher overall ratings vary between runs for borderline templates; per-question answers are more stable.
• lp_pulled_24h = liquidity fell to ≤20% of its running peak within 24 h of a snapshot one minute after launch.
• Labels propagated by lineage or shape assume the same code behaves the same; constants below 0x100000 (fees, bps) still distinguish shapes, larger ones (addresses, blocks, amounts) do not.
• Launch tables: snapshot blocks are interpolated from block timestamps (a few blocks off at most); the developer is whoever sent the pool-creation transaction, which for launchpads may be a relayer; 590 pre-minted launches have null developer columns because no public node kept the state needed for the starting balance; a few launches without an early-buyer sender (RPC gaps) are missing from early_buyers.

Sources and credits

On-chain data from Robinhood Chain public RPC endpoints; verified source from Sourcify; decompiler heimdall-rs 0.9.2; analysis with Slither; selector names from the openchain signature database. Warm-up contracts and Slither results from mwritescode/slither-audited-smart-contracts (MIT). Teacher labels generated with GLM-5.3 (Z.ai) and Claude (Anthropic).