Igris Solana token safety
Server Details
Solana token rug/honeypot checks: free quick check; full score paid via x402 (USDC Solana/Base).
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 3 tools
The three tools have clearly distinct roles: a free limited quick check, a paid full single-token risk check with holder/rugcheck/honeypot data, and a paid batch version for up to 10 mints. The descriptions explicitly explain when to use each, so an agent can select correctly without overlap confusion.
All tool names use the same snake_case prefix `solana_token_` and follow a readable variant pattern: quick_check, safety, safety_batch. There are no mixed conventions or vague verbs.
Three tools are well-scoped for a focused Solana token safety server: free quick check, paid full check, and paid batch check. Each tool earns its place without redundancy or excessive surface area.
The domain is Solana SPL mint risk assessment, and the surface covers free basic checks, full paid risk scoring with authorities, Token-2022 extensions, holder concentration, rugcheck flags, and a live Jupiter round-trip honeypot test, plus batch processing. No obvious lifecycle operation is missing for this use case.
Available Tools
3 toolssolana_token_quick_checkSolana token quick check (free)ARead-onlyInspect
FREE. On-chain check of a Solana SPL mint: mint authority, freeze authority, risky Token-2022 extensions. Returns risk score 0-100 (higher=riskier). For holder concentration, rugcheck flags and honeypot (sell-back) test use solana_token_safety.
| Name | Required | Description | Default |
|---|---|---|---|
| mint | Yes | base58 Solana SPL token mint address |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and openWorldHint, so safety is covered. The description still adds real context beyond them: the scope of the on-chain read, the return value semantics (risk score 0-100, higher = riskier), and that the call is free. It does not mention rate limits or caching, which keeps it just short of 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, each doing distinct work: cost, scope, and return contract, then the alternative routing. No filler and the most decision-relevant token ('FREE') is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description compensates by stating the return shape (risk score 0-100) and what dimensions are checked, which is enough for a single-parameter read tool. The only gap is that solana_token_safety_batch is never referenced, so batch-scale use is left to inference.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the single 'mint' parameter, which documents base58 format and the schema enforces 32-44 chars. The description adds nothing about the parameter, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource ('On-chain check of a Solana SPL mint') and enumerates exactly what is inspected: mint authority, freeze authority, risky Token-2022 extensions. It also names the sibling tool that covers the omitted checks, so an agent can place it precisely among the three siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly routes the agent: 'For holder concentration, rugcheck flags and honeypot (sell-back) test use solana_token_safety.' This is a clear when-to-use-this vs when-to-use-the-alternative statement, plus a cost cue ('FREE.') that helps when budget matters.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
solana_token_safetySolana token rug/honeypot score (0.01 USDC via x402)ARead-onlyInspect
PAID 0.01 USDC (x402, Solana or Base; pay via _meta['x402/payment']). Full rug/honeypot risk score for a Solana SPL mint: authorities, Token-2022 extensions, top-10 holder concentration excluding pools, rugcheck danger flags, and a live Jupiter $25 buy+sell round-trip cost. Use before swapping into an unknown token.
| Name | Required | Description | Default |
|---|---|---|---|
| mint | Yes | base58 Solana SPL token mint address |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare readOnlyHint and openWorldHint; the description adds critical non-structured behavior: a 0.01 USDC charge, the x402 payment rails (Solana or Base), and the exact field (_meta['x402/payment']) the caller must populate. Price, payment mechanics, and the paid-vs-free economics are all disclosed, which is exactly what an agent needs before incurring cost.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The mandatory-cost warning is front-loaded in caps before any capability detail, which is the right ordering for a paid tool. Two sentences, no filler; the feature enumeration earns its place by justifying the charge and setting expectations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With one fully described parameter, no output schema, and minimal annotations, the description covers everything an agent needs: cost, payment channel, what is analyzed, and when to invoke it. Nothing required to call it correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the single `mint` parameter (base58 SPL mint address, 32-44 chars), so the schema fully documents the input. The description restates the token type but adds no format or validation detail beyond it, making the baseline 3 correct.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific resource (Solana SPL mint) and enumerates exactly what the score covers: authorities, Token-2022 extensions, top-10 holder concentration, rugcheck flags, and a live Jupiter round-trip. The word "Full" implicitly distinguishes it from solana_token_quick_check, but the description never names either sibling, so differentiation is left to inference.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
"Use before swapping into an unknown token" gives a concrete trigger context for calling it. It stops short of when-not-to-use guidance or naming solana_token_quick_check/solana_token_safety_batch as cheaper/bulk alternatives, which matters because this is the paid tier.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
solana_token_safety_batchBatch Solana token scores (0.05 USDC for up to 10)ARead-onlyInspect
PAID 0.05 USDC (x402, Solana or Base). Full risk score for up to 10 Solana mints in one call (half the per-token price).
| Name | Required | Description | Default |
|---|---|---|---|
| mints | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare readOnlyHint and openWorldHint; the description adds genuinely useful behavioral context beyond them: the tool is paid (0.05 USDC via x402 on Solana or Base) and the batch is half the per-token price. It does not cover failure behavior for invalid mints or partial batches, so it stops short of a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, zero filler, with the payment cost front-loaded before the functional description. Slightly clipped to the point that the return value is left unstated.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a paid, single-parameter tool with no output schema, the description covers price, chain, and batch size but says nothing about what a 'full risk score' contains, how payment is settled/authorized, or what happens if fewer than 10 mints are supplied. Adequate but leaves real gaps for an agent invoking a paid call.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
One parameter with 0% description coverage per the metric, though the schema itself carries the base58 mint constraint and min/max items. The description reinforces the batch size cap ('up to 10') but adds no format, ordering, or deduplication semantics beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Full risk score for up to 10 Solana mints in one call'), so the agent knows this is a batch scoring tool. It implies differentiation from solana_token_quick_check via 'Full' and from solana_token_safety via the batch/10-mint scope, but never names either sibling explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The 'up to 10 ... half the per-token price' phrasing implies this is the choice when you have multiple mints and want cost savings, but there is no explicit when-to-use statement, no condition for preferring solana_token_quick_check or solana_token_safety, and no mention of the per-token alternatives' tradeoffs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
- First observed
solana_token_quick_check - First observed
solana_token_safety - First observed
solana_token_safety_batch
Related MCP Connectors
Solana token rug check before you buy: SAFE/CAUTION/DANGER from chain state, paid per call via x402.
Solana token risk: free preview tools; paid x402 full reports (Solana; swap-guard also Base).
Free token risk check (Base/Solana) + info on paid x402 reports. Not financial advice.
Rug-check & launch radar for trading agents: composite honeypot score, EVM+Solana, keyless x402.
Related MCP Servers
- AlicenseAqualityAmaintenanceOn-chain Solana token safety for trading agents — traces coordinated wallet funding, same-block Jito bundles, serial-rug deployers and live coordinated dumps into one Exit-Liquidity Risk verdict before a swap. Free tier, then $0.02 USDC/query via x402.152 npm1MIT
- AlicenseAqualityCmaintenancePaid access to Solana DeFi risk intelligence — rug/honeypot scans, liquidity-pool analysis, and wash-trade-filtered pool rankings. Automatically settles micropayments in USDC via x402.1068 npmMIT
- AlicenseAqualityAmaintenanceRug pull risk scores and on-chain forensics for memecoins on Solana, Ethereum, Base and Robinhood Chain - launch-bundle detection, funding-origin tracing, deployer history, insider networks and whale flow. 15 read-only tools.1515 npmMIT
- AlicenseAqualityAmaintenanceSolana memecoin rug check and token risk for trading agents in the trenches: pump.fun launches, calibrated rug probability with a published hit rate, sniper, insider and bundle detection, holder clusters, KOL trades, wallet history and a live sellability check for memecoins. Available as a remote MCP endpoint (OAuth or API key) and as an npm stdio package.2683 npm3MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.