Contract Interaction Replay Tool for Debugging

WHAT IT DOES

Contract Interaction Replay Tool for Debugging takes a transaction hash and fetches the full transaction details, receipt, and logs from the chain. It then attempts to simulate a static call replay of the contract interaction using the same calldata, sender, and value, providing developers with insight into what would happen if the same call were made again. The tool displays the transaction's from/to addresses, value, gas used, status, and all emitted logs—decoded when an ABI is provided. For contract interactions with calldata, it performs a static call against the target contract to show the current return value or error, helping debug why a transaction succeeded or failed. This is especially useful for investigating failed transactions, verifying contract behavior after upgrades, or understanding complex multi-call interactions.

HOW TO USE

Paste a transaction hash into the input field. Optionally, paste the contract ABI as a JSON array to enable log decoding and more detailed call data interpretation. Click "Replay transaction" to fetch the transaction data from the chain via your connected wallet provider. The tool displays the transaction summary, a list of all logs (raw or decoded), and a simulated static call replay result. The replay attempts to call the exact same method with the same parameters and value, returning the result or error message. This read-only operation is non-invasive and does not modify state or send any transactions.

TECHNICAL MECHANISM: TRANSACTION RETRIEVAL AND STATIC CALL REPLAY

The tool uses ethers.js to fetch the transaction and receipt from the provider. It extracts the calldata, target address, sender, and value. For log decoding, it builds an Interface from the user-provided ABI and iterates through receipt logs, parsing each against the interface. If no ABI is provided, logs are displayed as raw hex. The replay mechanism constructs a minimal Contract object with the transaction's target address and a function signature derived from the first 4 bytes of calldata (the method selector). It then invokes contract.callStatic with the original calldata, sender address, and value, all passed as overrides. This simulates the call exactly as it would execute in the current state, returning the output or propagating any revert reason. The tool handles errors gracefully, showing the revert reason when available. Unlike full transaction tracing which requires node-level debugging endpoints, this approach works with any standard JSON-RPC provider and does not require special permissions, making it accessible for all developers.

WHAT IT CANNOT SEE

Cannot execute transactions in a forked environment or simulate state changes beyond static call simulation—it only reads, never writes. Cannot replay transactions that depend on block-specific state that has since changed, such as selfdestructed contracts or storage that has been overwritten; the replay may differ from the original execution. Cannot reproduce events or logs that are not emitted during a static call (some events are only emitted on state-changing writes). Cannot guarantee that a replayed call will produce identical results due to state drift between the original block and current state. Cannot decode complex nested proxy calls without the full proxy chain implementation; it sees only the immediate target. Cannot identify the exact cause of a failed transaction without full trace data, which may not be available via standard RPC. Cannot replay private transactions or transactions from mempools not yet confirmed—they must be on-chain. Cannot account for transaction ordering or MEV that affected the original execution, as the replay ignores block context.

PLEASE NOTE

EVM chains only. This tool is read-only and does not send transactions or alter state. Static call replays may fail if the contract's current state differs significantly from the original execution state.