DEV Community: MrWizardlyLoaf

Token-2022 Traps That Drain AI Trading Agents (and How to Screen Them)

MrWizardlyLoaf — Tue, 23 Jun 2026 07:41:00 +0000

Most "rug pull" content on Solana is about classic SPL tokens — mint authority, liquidity pulls, whale dumps. But the sharper edge now is Token-2022: a newer token standard whose extensions give a creator powers a normal SPL token never had. For an autonomous trading agent that buys tokens by address, these are landmines.

Here are the extensions that actually drain agents, and how to screen for them before a buy.

The dangerous extensions

permanentDelegate — the single worst one. The creator holds a permanent delegate that can move or burn your tokens out of your wallet, any time, with no further approval. You hold the token; they hold the keys to it.
transferHook — a custom program runs on every transfer and can make selling fail under conditions the creator chooses.
pausable — transfers (including your sell) can be paused at will.
nonTransferable — the token literally cannot be moved once you hold it. Permanent honeypot.
defaultAccountState = frozen — new holder accounts start frozen; the issuer decides who can transact.

None of these are visible on a chart or a typical token page. They live in the mint account, and they are readable on-chain — if your agent reads them before trading.

Screen for them in one call

RugCheck AI reads the mint directly (getAccountInfo) and flags these extensions explicitly:

check_authorities("<mint>") -> mint/freeze authority + every Token-2022 extension, with the dangerous ones called out

scan_token("<mint>") -> { verdict: SAFE|CAUTION|DANGER, safety_score, risks: [...] }

A token carrying permanentDelegate or a transfer hook comes back DANGER with the reason spelled out, before your agent spends anything.

Why "read the chain directly" matters

Indexers and token lists often don't surface Token-2022 extension data, and they definitely don't have it for a token minted a minute ago. RugCheck AI calls getAccountInfo on the mint itself, parses the extensions, and gives a real verdict on a fresh launch instead of unknown. The screening tools are read-only and never touch your keys.

Wire it in

Standard Streamable HTTP MCP server, no install, no API key. Add an mcpServers entry named rugcheck-ai pointing at the endpoint in Cline, Claude Desktop (via npx mcp-remote), or Cursor.

Endpoint:

https://web-production-58d585.up.railway.app/mcp

Rule for your agent: on DANGER, skip the token. Repo and full 15-tool list: github.com/MrWizardlyLoaf/rugcheck-ai (official MCP Registry: io.github.MrWizardlyLoaf/rugcheck-ai).

How to Detect a Solana Honeypot Token Before Your Bot Buys

MrWizardlyLoaf — Fri, 19 Jun 2026 03:24:00 +0000

A honeypot is the cleanest way to drain a trading bot on Solana: the token lets you buy, but there is no way to sell. Your agent spends real USDC, receives tokens, and then discovers the exit is welded shut. The position is worth zero and there is nothing to do about it.

Honeypots don't show up on a price chart — the chart looks great, because everyone can buy and nobody can sell. You only find out at exit. So the check has to happen before the buy.

What makes a Solana token a honeypot

No live sell route — there is simply no route back to USDC/SOL on any DEX. The most common case.
Transfer restrictions — Token-2022 extensions like transferHook or pausable let the creator block transfers (and therefore sells).
Freeze authority — the issuer can freeze your account so the tokens can't move.

Detect it in one call

RugCheck AI is a remote MCP server. Point your agent at the endpoint and ask before any buy:

simulate_sell("<mint>") -> { sellable: true|false, verdict: "..." }

A token with no live sell route comes back sellable:false — that's the honeypot, even when nothing on-chain formally blocks the sell yet. For the full picture in one shot:

scan_token("<mint>") -> { verdict: SAFE|CAUTION|DANGER, safety_score, sellable, risks: [...] }

Or simulate the whole round-trip at your real size:

simulate_trade("<mint>", 100) -> { buyable, sellable, exit_usd, round_trip_loss_pct }

A honeypot shows buyable:true, sellable:false. A healthy token shows a small round-trip loss (slippage) and sellable:true.

A real one

I scanned a fresh pump token on 2026-06-17 (re-run to verify): scan_token returned DANGER, score 20 — no live sell route, 100% of supply held by a single wallet, $0 liquidity. An agent that bought it could never get out. That verdict is available before the buy, even though the token is too new to be indexed anywhere else.

Wire it into your agent

It's a standard Streamable HTTP MCP server. In Cline / Claude Dev, add an mcpServers entry named rugcheck-ai pointing at the endpoint url. In Claude Desktop, run it via npx mcp-remote. In Cursor, add it under Settings, MCP, Streamable HTTP.

Endpoint:

https://web-production-58d585.up.railway.app/mcp

Then the rule is simple: if sellable is false, do not buy. No install, no API key. Repo and full tool list: github.com/MrWizardlyLoaf/rugcheck-ai (official MCP Registry: io.github.MrWizardlyLoaf/rugcheck-ai).

How to Stop Your Solana AI Trading Agent From Getting Rugged

MrWizardlyLoaf — Wed, 17 Jun 2026 06:05:03 +0000

Autonomous trading agents on Solana have one expensive blind spot: they buy a token the same way they buy any other — except some of those tokens are honeypots you can buy but never sell, or have a live mint authority that dilutes you to dust a block later, or a Token-2022 extension that lets the creator move your balance straight out of your wallet.

A careful human checks the holders, the liquidity, maybe a rug checker. An agent, by default, checks nothing. One bad buy and the wallet is gone.

Here's how to give your agent the same pre-trade reflex a careful human has — as one MCP call before any buy.

The threat, concretely

Three things quietly drain agents on Solana:

Honeypots — you can buy, but there is no sell route. Your position is stuck at zero.
Live mint / freeze authority — the creator can inflate supply (your share to dust) or freeze your tokens in place.
Token-2022 traps — extensions like permanentDelegate (creator can move your tokens), transferHook / pausable (selling can be blocked), nonTransferable.

None of these show up on a price chart. All are readable directly from the token's mint account on-chain — if something reads it before the trade fires.

The fix: a pre-trade screen as an MCP tool

RugCheck AI is a remote MCP server that reads the mint directly (getAccountInfo) and returns a SAFE / CAUTION / DANGER verdict plus the specific risks — in one call, before your agent spends a cent. No install, no API key; you point your agent at the endpoint.

See it on real tokens

I scanned three real mainnet tokens (2026-06-17 — re-run to verify, live state changes):

Token	scan_token verdict	Why
BONK	SAFE / 100	authority renounced, liquid, sellable
USDC	CAUTION / 70	issuer keeps an active mint and freeze authority
a fresh pump token	DANGER / 20	no sell route (honeypot), 100% held by one wallet, $0 liquidity

The third one is the trap: an agent that bought it could never sell. RugCheck AI flags it before the buy — even though the token is too new to be indexed anywhere else. And notice USDC comes back CAUTION, not SAFE, because the issuer can still freeze your balance. The verdict tells you the truth, not a marketing label.

Wire it into your agent

Cline / Claude Dev (VS Code) — in cline_mcp_settings.json, add an mcpServers entry named rugcheck-ai with the url field set to the endpoint below.

Claude Desktop — in claude_desktop_config.json, add an mcpServers entry that runs npx -y mcp-remote <endpoint>.

Cursor — Settings, MCP, Add, Streamable HTTP, then paste the endpoint.

Endpoint:

https://web-production-58d585.up.railway.app/mcp

Then give your agent one rule: before any buy, call scan_token(mint) and refuse on DANGER.

scan_token("<mint>") -> { verdict, safety_score, sellable, risks: [...] }

SAFE -> proceed. CAUTION -> read the risks and size down. DANGER -> skip it.

More than one check

scan_token is the one-call verdict, but the server exposes 15 tools so an agent can drill in:

is_safe(mint) — a single boolean gate
simulate_sell(mint) — dedicated honeypot check (is there a live sell route?)
simulate_trade(mint, usd) — full round-trip: buy then sell back, see the real exit cost
holders_breakdown(mint) — top-holder concentration (dump risk)
check_authorities(mint) — mint/freeze authority + Token-2022 traps
scammer_dna(mint) — how much the token's structure looks like a deliberate scam
and execute_safe_swap(mint, wallet, usd), which re-screens and hands back an unsigned Jupiter swap for the agent to sign (it refuses anything that scans DANGER).

Why read the chain directly

Most "is this token safe" answers come from an indexer that hasn't seen a token minted 40 seconds ago — exactly when snipers buy. RugCheck AI calls getAccountInfo on the mint itself, so you get a real verdict on a fresh launch instead of unknown. The screening tools are read-only; the server never holds your keys.

Repo + full tool list: github.com/MrWizardlyLoaf/rugcheck-ai. Listed on the official MCP Registry as io.github.MrWizardlyLoaf/rugcheck-ai.

Screen before you buy. Your agent will thank you the first time it skips a honeypot.

RugCheck AI: On-chain Token Safety for Solana AI Trading Agents

MrWizardlyLoaf — Sat, 13 Jun 2026 03:36:05 +0000

If you're building autonomous trading agents on Solana, you've hit this problem: your agent needs to vet a token before it buys — but most agents trade blind. They have no idea whether a token is a rug pull, a honeypot, or has an active mint authority that can dilute holders to zero.

I built RugCheck AI to fix this: an MCP server that screens any SPL / Token-2022 token for the common scam patterns, then builds the swap as an unsigned, screened Jupiter transaction you sign — screening and execution in one place.

What it checks

Mint & freeze authority — is supply still mintable? Can your tokens be frozen in place?
Honeypot detection — can the token actually be sold, or only bought?
Token-2022 traps — permanent delegate, transfer hooks, default-frozen state.

Tools

verify_token_safety — full on-chain safety audit
check_authorities — mint / freeze / Token-2022 trap detection
simulate_sell — honeypot check
execute_safe_swap — screened execution (unsigned Jupiter tx you sign)

Connect

RugCheck AI is listed on the official MCP Registry as io.github.MrWizardlyLoaf/rugcheck-ai. Remote endpoint, no install:

https://web-production-58d585.up.railway.app/mcp

Or self-host — it's open source (MIT) on GitHub: https://github.com/MrWizardlyLoaf/rugcheck-ai

Why pre-trade screening matters

A rug pull on Solana often looks fine at the moment of purchase — liquidity is there, the chart is green. The trap is in the authority: a live mint authority lets the deployer print unlimited supply after you buy; a freeze authority can lock your tokens so you can never sell. An autonomous agent that doesn't read these on-chain fields walks straight into it. RugCheck AI reads them directly and gives a verdict on a fresh launch instead of unknown.

Built for Solana trading agents. Feedback welcome.