Skip to main content
command CX Codex

token-scan — Claude Code command: rug pull audit for tokens

token-scan — a Claude slash command that hunts rug-pull vectors in token and meme coin contracts on Solidity and Solana. Useful before you buy an unknown token or ship your own.

MIT ★ 16,193 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add elementalsouls/Claude-BugHunter
/plugin install claude-bughunter@elementalsouls
Open on GitHub

What token-scan does

Point it at a contract file or a whole directory and it walks eight classes of rug-pull trick: hidden mint, honeypot traps, fee changes, liquidity pulls, bonding-curve games, leftover authorities, fake ownership renounce, sandwich amplification. Solidity on EVM and Rust/Anchor on Solana both work; add --chain solana for the latter.

The engine is a set of greps. It looks for mint calls with no supply cap, blacklist mappings, fee setters with no upper bound, emergencyWithdraw, mutable curve parameters, set_authority calls that leave a key alive. A local token_scanner.py on PATH gives a faster risk score if you have one; without it nothing breaks, because the manual pass covers all eight classes by itself. Five off-chain questions come first: is the source verified, does the deployer have a rug history, has the token traded for more than an hour, is there more than $5K of liquidity, is it a proxy with a live admin. Any "no" means the code deserves suspicion.

You get a 0-100 score, a verdict from CLEAN to CRITICAL RISK, and findings with file:line. After five minutes with no hits across every class, the command tells you to stop instead of chasing phantom bugs.

What it helps with

  • Check an unfamiliar token contract for hidden mint paths
  • Spot a honeypot before buying: blacklists, transfer hooks, freeze authority
  • Audit a Solana program for retained mint and upgrade authorities
  • Tell a fake renounce from a real one
  • Produce a findings report with line numbers and a risk score

Example prompts for the agent

  • Run /token-scan contracts/Token.sol and list the findings with line numbers.
  • Scan the Solana program: /token-scan programs/token/ --chain solana --recursive, focus on mint_authority and freeze_authority.
  • Save the audit with /token-scan src/ --recursive --output findings/report.md.

How to install token-scan

1Plugin marketplace

/plugin marketplace add elementalsouls/Claude-BugHunter
/plugin install claude-bughunter@elementalsouls

2Manually: put the files in place

.claude/commands/token-scan.md

Call it with /token-scan. For all projects use ~/.claude/commands/

Questions about token-scan

How do I install token-scan in Claude Code?

Add the marketplace with /plugin marketplace add elementalsouls/Claude-BugHunter, then install the plugin: /plugin install claude-bughunter@elementalsouls. The command appears as /token-scan.

What does token-scan do?

It greps token source for eight classes of rug-pull vector, then returns a 0-100 risk score, a verdict and findings with file and line. EVM Solidity and Solana Rust/Anchor are covered.

Do I need the Python scanner for it to work?

Only as a shortcut. With no token_scanner.py on PATH the command runs the manual grep audit, and that pass already covers all eight classes.

Source text

token-scan.md · MIT
---
name: token-scan
description: Meme coin and token security scan — checks for rug pull vectors (hidden mint, honeypot, fee manipulation, LP lock bypass, authority retention, bonding curve exploits, fake renounce, sandwich amplification). Manual 8-class grep audit (with an optional automated scanner if present). Usage: /token-scan <contract_path_or_dir> [--chain solana]
---

# /token-scan

Fast rug pull detection for meme coins and token contracts. Covers EVM (Solidity) and Solana (Rust/Anchor).

## Usage

```
/token-scan contracts/Token.sol                          # Single EVM contract
/token-scan src/ --recursive                             # Scan entire directory
/token-scan programs/token/ --chain solana --recursive   # Solana program
/token-scan contracts/Token.sol --output findings/report.md  # Save report
```

## Step 0: Quick Kill Signals

Before scanning code, check:

```
[ ] Contract is verified (source code available)?
[ ] Deployer has no rug history?
[ ] Token has been trading > 1 hour?
[ ] Liquidity > $5K?
[ ] Not a proxy with retained admin?
```

If ANY answer is NO → flag and proceed with extreme caution.

## Step 1: Optional Automated Scanner

> **Optional accelerator — not bundled by default.** If you have a local
> `token_scanner.py` (or any rug-vector scanner) on PATH, run it first for a quick
> risk score. If you don't, **skip straight to Step 2** — the manual 8-class grep
> audit below is the real, self-contained check and needs no extra tooling.

```bash
# If present:
python3 tools/token_scanner.py <contract_path>            # EVM
python3 tools/token_scanner.py <program_dir> --chain solana --recursive  # Solana
```

The manual audit (Steps 2-9) covers all 8 bug classes via grep and is sufficient
on its own.

## Step 2: Hidden Mint Check

```bash
grep -rn "function mint\|_mint(\|_balances\[.*\] +=" src/ --include="*.sol" | grep -v "test\|lib"
grep -rn "delegatecall" src/ --include="*.sol"
# Solana:
grep -rn "MintTo\|mint_to\|mint_authority" src/ --include="*.rs"
```

Look for: mint without MAX_SUPPLY cap, direct balance manipulation, delegatecall to unknown targets.

## Step 3: Honeypot Check

```bash
grep -rn "blacklist\|isBlacklisted\|_bots\|maxTxAmount\|approve.*override" src/ --include="*.sol"
# Solana:
grep -rn "freeze_authority\|transfer_hook\|permanent_delegate" src/ --include="*.rs"
```

Look for: blacklist mappings, max tx setters without minimum bound, approve overrides that don't call super.

## Step 4: Fee Manipulation Check

```bash
grep -rn "setFee\|setSellFee\|_taxFee\|_sellFee" src/ --include="*.sol"
grep -rn "function set.*Fee" -A5 src/ --include="*.sol" | grep -v "require\|MAX"
```

Look for: fee setters without upper bound, fee exclusion for owner.

## Step 5: LP Drain Check

```bash
grep -rn "migrateLP\|emergencyWithdraw\|\.sync()\|setPair\|setRouter" src/ --include="*.sol"
grep -rn "addLiquidityETH" -A5 src/ --include="*.sol" | grep "owner\|msg.sender"
```

Look for: LP migration functions, emergency withdraw, auto-LP to owner wallet.

## Step 6: Bonding Curve Check

```bash
grep -rn "virtualReserve\|setCurve\|graduate\|bonding_curve" src/ --include="*.sol" --include="*.rs"
```

Look for: mutable curve parameters, manipulable graduation threshold.

## Step 7: Authority Check (Solana)

```bash
grep -rn "mint_authority\|freeze_authority\|update_authority\|close_authority" src/ --include="*.rs"
grep -rn "set_authority.*None" src/ --include="*.rs"
grep -rn "upgrade_authority" src/ --include="*.rs"
```

Look for: retained authorities that should be None, upgradeable programs.

## Step 8: Fake Renounce Check

```bash
grep -rn "renounceOwnership.*override" src/ --include="*.sol"
grep -rn "_shadowAdmin\|_backupOwner" src/ --include="*.sol"
```

Look for: overridden renounce without actual transfer, secondary admin roles.

## Step 9: Sandwich Amplification Check

```bash
grep -rn "swapExactTokensForETH" -A5 src/ --include="*.sol" | grep "0,"
grep -rn "swapThreshold\|_rebase\|reflect()" src/ --include="*.sol"
```

Look for: auto-swap with amountOutMin=0, rebase on every transfer.

## Output

Summarize the audit (whether driven by the manual steps or the optional scanner) as:
- **Risk score** (0-100) based on finding severity
- **Verdict** (CLEAN / LOW RISK / MEDIUM RISK / HIGH RISK / CRITICAL RISK)
- **Individual findings** with file:line, code snippet, and recommendation

## What to Do Next

- If CRITICAL findings → **DO NOT INTERACT**. Report if on Immunefi/Code4rena.
- If HIGH findings → Manual deep review. May be intentional design. Check deployer history.
- If MEDIUM findings → Flag for awareness. Likely not rug but worth monitoring.
- If CLEAN → Token passes automated checks. Still verify on-chain state manually.

## 5-Minute Rule

If you've been scanning for 5 minutes and found no red flags across all 8 classes + automated scan → the token is likely clean. Move on. Don't hunt for phantom bugs.

© Sachin Sharma · MIT · elementalsouls/Claude-BugHunter

Similar slash commands

All slash commands for Security →

From the same set92

The whole set →
validate validate — a validation command that culls weak findings before report writing. Runs a 7-Question Gate and 4-gate checklist to prevent submissions that damage your validity ratio. CX Codex +1 ★ 16,193repo stars autopilot autopilot is a Claude Code command for autonomous vulnerability hunting. It checks scope, ranks targets, validates findings, and drafts reports. CX Codex +1 ★ 16,193repo stars hunt-clickjacking hunt-clickjacking is a Claude Code skill that checks whether a page can be framed and used to trigger a sensitive action. It investigates clickjacking in web applications. CX Codex +1 ★ 16,193repo stars hunt hunt dispatches vulnerability assessments across Red Team and WAPT workflows with scope boundaries. CX Codex +1 ★ 16,193repo stars chain Takes a confirmed bug A and finds B and C to combine into a higher-severity chain. For bug hunters stuck with Low or conditionally valid findings. CX Codex +1 ★ 16,193repo stars hunt-nosqli hunt-nosqli helps detect NoSQL injection flaws in MongoDB, CouchDB, and Redis. It assists developers and testers during API security reviews and auth auditing. CX Codex +1 ★ 16,193repo stars hunt-forgot-password The hunt-forgot-password skill checks account recovery flows for token leaks, replay, and missing request limits. Use it when auditing a password reset feature. CX Codex +1 ★ 16,193repo stars hunt-deserialization hunt-deserialization — a skill for hunting deserialization bugs in Java, PHP, Python, .NET and Ruby. Tests ysoserial gadget chains, PHP object injection, pickle RCE, BinaryFormatter and Log4Shell. CX Codex +1 ★ 16,193repo stars

Project sponsors

Companies that keep this analytics open