Memory Layout Inspector at Breakpoint

WHAT IT DOES

Memory Layout Inspector at Breakpoint is a developer tool that captures the complete execution context of an EVM contract at a specific program counter (PC) breakpoint. Given a contract address and a target PC, it retrieves and displays: the contract's current bytecode, the full memory contents at that PC, stack items with their hex and decoded values, storage slots that have been modified, and memory ranges you specify by offset. All previous inspection records are stored locally for side-by-side comparison across breakpoints or contract versions.

HOW TO USE

Provide a contract address (0x-prefixed) and a PC value in decimal or hex. Optionally, supply one or more memory offset ranges (e.g., 0x00-0x3F, 0x80-0x9F) to highlight specific regions. The tool connects to your configured EVM RPC endpoint, executes a debug_traceCall or trace_transaction against the block where the contract code exists, and halts execution exactly at the given PC. It then surfaces the captured state in a structured JSON output with labeled sections for memory, stack, storage, and bytecode. Previous inspections remain accessible via a history panel, enabling you to compare memory layouts across different breakpoints or after contract upgrades.

WHY OTHER TOOLS FAIL, AND THIS ONE DOES NOT

Most block explorers and debuggers only show storage or memory at transaction boundaries or revert points—never at an arbitrary PC inside a running contract. They rely on post-execution diffs, which discard intermediate memory states. This tool instead leverages the EVM's built-in debug_trace infrastructure with a custom tracer that inserts a breakpoint callback. When the tracer reaches the specified PC, it captures the full memory array, stack snapshot, and storage read/write set from the execution frame before any further opcodes execute. The tracer does not simulate or re-interpret the bytecode; it hooks directly into the interpreter's state at that instruction, giving you exactly what the contract sees at that moment. Public RPCs often reject large memory dumps or throttle debug traces, so the tool chunks memory retrieval (64 bytes at a time) and automatically retries with exponential backoff when it receives rate-limit errors. It also caches bytecode and storage proofs to avoid redundant network calls. This chunk-and-backoff mechanism is critical because different RPC providers cap debug_trace response sizes differently—a single refusal does not abort the entire inspection.

WHAT IT CANNOT SEE

- The tool cannot guarantee that the captured memory layout is accurate if the RPC node returns a stale or inconsistent state due to reorgs or pending blocks.

- It cannot detect whether the breakpoint PC is actually reachable in the contract's execution flow; if the PC is never hit, the tracer will time out or return an empty state.

- It cannot ensure that the memory contents are correct when the contract uses self-destruct or delegatecall, as those modify the execution context in ways the tracer may not fully resolve.

- It cannot validate that the offset ranges you provide are appropriate for the current memory size; requesting out-of-bounds offsets yields empty or padded data, but the tool does not warn you about this.

- It cannot detect if the contract's bytecode has been modified since the inspection block (e.g., via a selfdestruct or a new deployment at the same address).

- It cannot verify that the memory layout is reproducible across different node implementations or client versions; Geth and Nethermind produce slightly different trace outputs for edge cases.

- It cannot predict if the memory layout will change in future EVM upgrades (e.g., EIP-3540 or EOF), and it does not support post-Merge PoS consensus quirks beyond basic debug_trace.

PLEASE NOTE

This tool works exclusively on EVM-compatible chains (Ethereum mainnet, Goerli, Sepolia, Polygon, Arbitrum, Optimism, and any chain that supports the standard debug_traceCall or debug_traceTransaction RPC methods). It does not support non-EVM chains (Solana, Sui, Aptos, etc.) or chains that lack a debug namespace. Some RPCs require an archive node for historical block inspections; if your RPC does not provide historical state, you may only inspect the latest block. The tool is free and does not store any data on external servers—all inspection records remain in your browser's local storage unless you export them.