Function Dependency Graph Generator

WHAT IT DOES

This tool generates function dependency graphs from smart contracts by analyzing internal calls, trace patterns, and function relationships. It constructs a directed graph showing which functions depend on others, mapping call hierarchies, dependency chains, and function relationships. The tool analyzes contract source code, ABI data, and transaction traces to identify function calls, dependencies, and call patterns. Results are presented as a detailed dependency graph with function nodes, dependency edges, call counts, and relationship descriptions. This is essential for developers understanding contract architecture, auditors analyzing call paths, and teams documenting function relationships.

HOW TO USE

Connect your wallet (read-only, no transaction required) and select the target network. Enter the contract name and address, and set the lookback blocks for dependency analysis. Click "generate dependency graph" and the tool will verify the contract, analyze internal calls and trace patterns, and generate a structured dependency graph. Results display a summary with contract details and function count, a text-based dependency graph showing functions and their dependencies, detailed node cards showing each function with its dependencies, callers, and description, and a table of all functions with their dependencies. Use the report to understand function relationships, identify dependency chains, and analyze contract architecture.

TECHNICAL MECHANISM

The generator uses ethers.js v5.7.2 to perform a multi-stage dependency graph generation process. First, it calls eth_getCode to verify the contract is deployed and uses block explorer APIs to fetch verification status, source code, and ABI. The tool then retrieves transaction traces using debug_traceTransaction (when available) or analyzes historical logs via eth_getLogs across the specified block range to reconstruct call patterns. It parses the contract source code to identify internal function definitions and calls, mapping function signatures from the ABI to human-readable names. The tool constructs a directed graph where nodes represent functions and edges represent dependencies (calls from one function to another). It analyzes call patterns to identify which functions call which others, including external calls, internal calls, and library calls. Each function node includes its name, signature, dependencies (functions it calls), callers (functions that call it), and a description. Results are compiled into a structured report with detailed graph information, dependency mappings, and call relationship descriptions.

WHAT IT CANNOT SEE

This tool cannot generate graphs for contracts that are not verified or have opaque implementation details where function bodies cannot be analyzed. It is limited by the RPC provider's rate limits and availability of debug_traceTransaction, which may be restricted on some providers (e.g., rate-limited, disabled, or only available for archival nodes). It cannot capture dynamic dependencies that depend on runtime conditions or external state—only statically or historically observable dependencies are included. The analysis relies on the accuracy and completeness of contract verification and trace data; incomplete source code or missing trace data may produce incomplete graphs. It cannot analyze contracts that use delegatecall or proxy patterns without full trace data, as these patterns may obscure the actual call hierarchy. The tool is limited to the specific contract instances and call patterns that are accessible via RPC. It cannot guarantee that generated graphs capture all possible dependency paths without exhaustive transaction analysis across a large number of transactions. The graph is a representation of observed and statically analyzed call patterns and may not reflect all possible contract interactions.

PLEASE NOTE

This is a read‑only analytics tool—it never submits transactions or modifies contract state. It is designed for EVM‑compatible chains and works best with verified contracts and providers that support debug_traceTransaction or have comprehensive source code. The generated dependency graphs are for informational and documentation purposes only and should not be considered a comprehensive behavioral analysis. Always verify function relationships against actual contract behavior and test edge cases. The tool's graph generation is heuristic and based on observed and statically analyzed patterns—customize or refine the graph as needed for your specific documentation requirements.