EVM MCP Auditor
This server provides EVM smart contract security auditing and blockchain telemetry tools for Claude/Claude Code.
Audit Solidity contracts for vulnerabilities (reentrancy, unsafe delegatecall, tx.origin auth, unchecked calls, timestamp dependency, selfdestruct, floating pragma, missing zero-address checks) and generate a security score.
Fetch verified source code of smart contracts from block explorers across Ethereum, Base, Arbitrum, Optimism, Polygon, and BSC.
Decode raw transaction calldata into function selectors, parameter segments, and byte length.
Estimate gas prices and get real-time network execution telemetry across supported EVM networks.
Provides tools for auditing EVM smart contracts on Ethereum and compatible networks, including static vulnerability analysis, fetching verified source code, decoding calldata, and estimating gas costs.
Supports multi-chain telemetry and security auditing of smart contracts on Optimism, including fetching verified source code, decoding calldata, and estimating gas costs on the Optimism network.
Supports multi-chain telemetry and security auditing of smart contracts on Polygon, including fetching verified source code, decoding calldata, and estimating gas costs on the Polygon network.
Enables static security analysis of Solidity smart contracts for vulnerabilities such as reentrancy, unsafe delegatecall, and timestamp dependency, covering SWC/CWE categories and providing audit results.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@EVM MCP AuditorAudit this Solidity contract for security vulnerabilities"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
š”ļø EVM MCP Auditor
Production-grade Model Context Protocol (MCP) server for EVM Smart Contract security auditing, static vulnerability analysis, and multi-chain telemetry for Claude & Claude Code.
ā” Overview
EVM MCP Auditor connects Anthropic's Claude, Claude Desktop, and Claude Code CLI directly to Ethereum and EVM ecosystems. It equips Claude with specialized security auditing tools to automatically inspect Solidity smart contracts for critical attack vectors, fetch verified source code from block explorers, decode raw transaction calldata, and estimate multi-chain gas costs.
āāāāāāāāāāāāāāāāāāāāāāāāāāāāā āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā
ā ā stdio ā ā
ā Claude Desktop / Code ā āāāāāāāŗ ā EVM MCP Auditor Server ā
ā (Anthropic AI) ā ā (@zalana/evm-mcp-auditor) ā
ā ā ā ā
āāāāāāāāāāāāāāāāāāāāāāāāāāāāā āāāāāāāāāāāāāāāā¬āāāāāāāāāāāāāāāāā
ā
ā¼
āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā
ā EVM Networks & Explorers ā
ā ⢠Ethereum ⢠Base ⢠Arbitrum ā
ā ⢠Optimism ⢠Polygon ⢠BSC ā
āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāRelated MCP server: Farofino MCP Server
š Features & MCP Tools
MCP Tool | Description |
| Run static security analysis on Solidity code (Reentrancy, Unsafe Delegatecall, |
| Pull verified contract source code directly from block explorers across 6 EVM networks. |
| Decode raw transaction hex data into 4-byte function selectors and parameter chunks. |
| Fetch real-time gas telemetry across Ethereum, Base, Arbitrum, Polygon, Optimism, and BSC. |
š¦ Quickstart & Installation
Option 1: Claude Desktop Integration
Add the following snippet to your claude_desktop_config.json:
{
"mcpServers": {
"evm-auditor": {
"command": "npx",
"args": ["-y", "@zalana/evm-mcp-auditor"]
}
}
}Option 2: Claude Code CLI
claude mcp add evm-auditor npx -y @zalana/evm-mcp-auditorOption 3: Local Development
# Clone repository
git clone https://github.com/zalana28/evm-mcp-auditor.git
cd evm-mcp-auditor
# Install dependencies
npm install
# Run automated test suites
npm test
# Build TypeScript to dist/
npm run build
# Run local MCP server
npm startš”ļø Supported Vulnerability Scanners (SWC / CWE)
EVM-SEC-001: Reentrancy (Checks-Effects-Interactions violation)
SWC-107/CWE-841EVM-SEC-002: Arbitrary / Uncontrolled Delegatecall
SWC-112/CWE-829EVM-SEC-003: Vulnerable Authentication via
tx.originSWC-115/CWE-287EVM-SEC-004: Unchecked Return Value of Low-Level Call
SWC-104/CWE-252EVM-SEC-005: Block Timestamp Manipulation
SWC-116/CWE-330EVM-SEC-006: Deprecated
selfdestruct/ Unprotected State LockSWC-106/CWE-284EVM-SEC-007: Floating Pragma Compiler Warning
SWC-103/CWE-664EVM-SEC-008: Missing Zero-Address (
address(0)) Setter ValidationSWC-100/CWE-20
š¤ Contributing
Contributions, issues, and feature requests are welcome! Please check the Contributing Guide.
š License
This project is licensed under the MIT License.
Built with ā” by Zalana for the global Open-Source and Web3 developer community.
Available Tools
4 toolsevm_audit_contractA
Audit Solidity smart contract source code for critical security vulnerabilities (Reentrancy, Unsafe Delegatecall, Tx.Origin authentication, Unchecked Calls, etc.) and generate a security score.
| Name | Required | Description | Default |
|---|---|---|---|
| sourceCode | Yes | The complete Solidity source code to analyze. | |
| contractName | No | Optional name of the target contract. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It states the tool analyzes for specific vulnerabilities and gives a security score, but does not disclose whether it returns a detailed report, whether it has limitations (e.g., only certain Solidity versions), or whether any side effects (none expected). Moderate clarity.
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?
A single concise sentence that communicates core purpose and outputs. No fluff, but it lacks a brief note on output specifics that could enhance without much length.
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 two params, no output schema, and no annotations, the description is adequate but not thorough. It explains the audit scope and output score, but does not mention the output format (e.g., JSON report), severity levels, or any limitations, leaving some agent uncertainty.
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 coverage is 100% with both parameters documented. The description adds that sourceCode must be complete and the target contract is optional, which aligns with the schema. It doesn't need to add much beyond the schema, but does note completeness requirement.
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?
The description specifies the tool audits Solidity source code for specific vulnerability types and generates a security score. It clearly distinguishes from siblings like evm_estimate_gas and evm_decode_calldata, though it lacks explicit comparison to evm_fetch_source.
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 description implies usage for security checking of Solidity code, but provides no guidance on when to use this versus alternatives, prerequisites (e.g., should code be compiled first), or what scenarios warrant this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
evm_decode_calldataA
Decode raw EVM transaction calldata into function selector, parameter segments, and byte length.
| Name | Required | Description | Default |
|---|---|---|---|
| calldata | Yes | Hex encoded transaction calldata starting with 0x. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavior disclosure. It states what the tool returns (decoded components) but does not mention error handling, input validation, or any side effects. It adds some value by specifying the output structure beyond the schema, but it omits important behavioral details.
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 description is a single, well-structured sentence that directly states the tool's purpose and outputs. No unnecessary words or repetition, making it highly concise and easy to parse.
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 simple tool with one parameter and no output schema, the description provides sufficient context about the operation and expected output. It could be more detailed about the exact format of the decoded segments, but overall it is complete enough for a decode function.
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?
The schema already provides 100% coverage for the single parameter 'calldata', specifying it as hex-encoded and starting with 0x. The tool description does not add further semantic meaning to the parameter, so the baseline score of 3 is appropriate.
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?
The description uses a specific verb 'Decode' with a clear resource 'raw EVM transaction calldata' and explicitly lists the output components (function selector, parameter segments, byte length). It is easily distinguishable from sibling tools like evm_estimate_gas or evm_audit_contract.
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 description implies when to use the tool (whenever raw EVM calldata needs decoding) but does not explicitly mention alternatives or exclusion scenarios. The context is clear enough for an AI agent to infer the appropriate use case, but it lacks explicit guidance on when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
evm_estimate_gasB
Get real-time gas price and network execution telemetry across supported EVM networks.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | No | Network to query gas price for (ethereum, base, arbitrum, optimism, polygon, bsc). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations to rely on, so the description carries the full burden of behavioral disclosure. It mentions 'real-time' and 'telemetry' but does not disclose whether this is a read-only operation, any rate limits, or what happens if the network is unsupported. The description is a bit vague about the exact behavior.
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 description is a single sentence with no fluff. It is concise and front-loaded with the main purpose ('real-time gas price and network execution telemetry'). No wasted words.
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?
Given the tool has only one parameter with full schema coverage and no output schema, the description is fairly complete. However, it could be more explicit about the output format or additional telemetry details, but for a simple query tool, it is reasonably sufficient.
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?
The schema description coverage is 100%, and the parameter 'chain' has an enum with descriptions for each value. Since the schema already explains the parameter, the description adds no extra meaning beyond what's in the schema. Baseline 3 is appropriate.
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?
The description clearly states the tool provides real-time gas price and network execution telemetry across supported EVM networks. It distinguishes itself from siblings like evm_audit_contract, evm_fetch_source, and evm_decode_calldata by focusing on network-level telemetry rather than contract or transaction data.
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 description implies usage for querying gas prices and telemetry, but it does not explicitly state when to use this over alternatives or provide exclusions. Given the sibling tools are quite different, the context is somewhat clear, but explicit guidance is missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
evm_fetch_sourceA
Fetch verified smart contract source code from block explorers across Ethereum, Base, Arbitrum, Optimism, or Polygon.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | No | Target blockchain network (ethereum, base, arbitrum, optimism, polygon, bsc). Default is ethereum. | |
| contractAddress | Yes | The 0x contract address. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the behavioral transparency burden. It does convey that this is a read-only fetch from block explorers and that the source must be verified, which is minimally viable. However, it does not describe failure behavior, return format, or external dependencies like API rate limits.
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?
A single, front-loaded sentence that immediately states the operation and scope. Every word earns its place, and there is no padding or repetition.
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 simple two-parameter read operation, the description is largely complete: it names the resource, the chain family, and the source of data. Minor gaps remain because there is no output schema and no mention of BSC, but the schema covers the chain enum and the operation is straightforward.
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%, so the input schema already documents both parameters and the chain enum. The description adds no additional parameter-level meaning and even omits BSC from the chain list, though the schema includes it.
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?
Description uses a specific verb ('Fetch') and a specific resource ('verified smart contract source code'), and names the supported chains. It also clearly distinguishes the tool from sibling tools that estimate gas, audit contracts, or decode calldata.
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 description gives no explicit guidance on when to choose this tool over alternatives, nor does it state prerequisites or exclusions. Usage context is only implied by the tool name and the phrase 'verified smart contract source code.'
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. Dates show when Glama detected each change.
4 tool updates
v1.0.0- First observed
evm_audit_contract - First observed
evm_decode_calldata - First observed
evm_estimate_gas - First observed
evm_fetch_source
TDQS
Scored across 4 tools
Each tool occupies a completely distinct role: estimating gas, auditing source, fetching source, and decoding calldata. There is zero functional overlap between the four, eliminating any chance of an agent selecting the wrong tool for a given intent.
All tools follow a flawless 'evm_verb_noun' snake_case convention with no exceptions. The consistent prefix plus action word makes the API predictable and easy to reason about.
Four focused tools is perfectly scoped for a specialized auditing server covering the key audit workflow without bloat. It hits the sweet spot of being comprehensive for its domain without unnecessary features.
The core fetch-source-and-audit workflow is well covered, with useful supporting utilities for gas analysis and calldata decoding. However, there's no way to list past audits, compare versions, or interact with the broader transaction context, which are minor gaps for a full auditing lifecycle.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
EVM audit (Slither + source + security.txt + MCP-probe + wallet-exposure). 6 tools + /trace.
DeFi safety layer for AI agents: wallet safety, token risk, tx decode/simulate. 20 tools.
Pay-per-call (x402/USDC-Base) web + crypto data tools for AI agents: audit, extract, crypto, DeFi.
AI security scanner for Solidity + free CC0 dataset of Sherlock audit-competition acceptance rates.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables AI coding agents to scan smart contracts and code for vulnerabilities, check against 12 famous-hack patterns, and return public security receipts directly in the IDE.46MIT
- AlicenseNot gradedqualityCmaintenanceEnables smart contract security auditing using Slither, Aderyn, and custom pattern analysis through the Model Context Protocol, allowing AI assistants to run static analysis and vulnerability checks on Solidity and Vyper contracts.1Apache 2.0
- AlicenseAqualityDmaintenanceConnects AI assistants to Solodit's 49,000+ blockchain vulnerability database, enabling search, browse, and lookup of audit findings directly from your AI workflow.4MIT
- AlicenseNot gradedqualityBmaintenanceAI-powered smart contract security analysis for AI agents and developers, enabling scanning of Solidity repos for vulnerabilities.168MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/zalana28/evm-mcp-auditor'
If you have feedback or need assistance with the MCP directory API, please join our Discord server