Contract Paused Error Explainer

WHAT IT DOES

Contract Paused Error Explainer takes a pending or recent transaction hash and determines whether the target contract is currently paused. Many EVM contracts implement a pause mechanism (often via OpenZeppelin's Pausable contract) that allows an owner or admin to halt all non‑admin functions in case of emergency, maintenance, or security incidents. If a contract is paused, any transaction that tries to call a non‑admin function will revert with a "Pausable: paused" error. This tool reads the transaction's target address, then calls the contract's paused() or isPaused() view function at the current block to check the pause state. It also reads the contract's owner or admin address (via owner() or admin()) and attempts to fetch any stored pause reason or timestamp. Additionally, it scans historical logs (using chunked, back‑off‑aware log fetching) to detect recent Paused and Unpaused events, providing context on when and how often the contract has been paused. The output includes the current pause state, the owner/admin who can unpause, any available reason, and a plain‑language explanation of whether the transaction will fail and what the user should do.

HOW TO USE

Paste any transaction hash into the input field, select the network, and click "Check paused". The tool connects to your wallet via the EVM bridge (read‑only; it never signs or sends anything) to fetch the transaction details and the target contract's pause state. It attempts multiple pause function signatures (paused() and isPaused()) to maximize compatibility. It also reads owner/admin addresses, pause reason strings, and paused timestamps if exposed. Historical logs are fetched in chunks (500 blocks per request) with automatic backoff and halving on failure to avoid public RPC caps. The AI layer generates a plain‑English summary: whether the transaction will revert due to the contract being paused, who can unpause it, and what action the user can take. You can click on the transaction hash or contract address to view them on the block explorer.

CHUNKED LOG SCANNING WITH EXPONENTIAL BACKOFF

Many public RPCs cap eth_getLogs requests to a maximum block range (often as low as 1000 blocks). A full‑range request for logs over 10,000 blocks will fail with "block range too large" or "query exceeds limit." This tool automatically chunkes log requests into 500‑block slices to stay within safe limits. If a chunk fails (e.g., due to a timeout or a stricter per‑provider cap), it halves that chunk and retries recursively, ensuring that even with aggressive RPC limits, the tool eventually retrieves all relevant logs without manual intervention. This backoff strategy is critical for reliably detecting historical pause events across different providers, which vary widely in their block range allowances. The tool also caches the current block number at the start of the scan to ensure consistency across all log requests.

WHAT IT CANNOT SEE

This tool cannot detect paused states that depend on off‑chain state (e.g., a contract that is paused for maintenance that is not reflected in a public variable, or a pause that is controlled by an off‑chain governance vote that hasn't been executed yet). It cannot predict future unpausing events or emergency unpausing that might occur before the transaction is mined—the check reflects the current block, not the future. It cannot verify that the sender intended to interact with the contract despite it being paused—the tool reads what is on‑chain, not the user's intent. It cannot detect paused states in contracts that use non‑standard pause patterns (e.g., pause logic that is not exposed via a public view function, or pause that is managed through a separate module or factory). It cannot guarantee that a retry will succeed once the contract is unpaused, as other state changes may also be required. It cannot detect if the pause is a security measure or a temporary maintenance flag—this tool only checks whether the paused state is active, it does not assess intent or risk. It also cannot detect contract pauses that are implemented at the proxy level (e.g., pause in the proxy's admin layer) without additional inspection of the proxy's implementation address.

PLEASE NOTE

This tool works only for EVM‑compatible chains (Ethereum, Polygon, BSC, Arbitrum, Optimism, Avalanche C‑chain, etc.) and relies on standard pause function signatures (paused() and isPaused()). It does not support custom pause implementations that use non‑standard naming or storage patterns. All explanations are AI‑generated from data the app reads on‑chain—the AI synthesizes the pause state, owner/admin, event history, and transaction context into plain English, but it does not have special access to private contract logic or off‑chain data. Always review what you are actually signing in your wallet before approving any transaction; a pause check does not replace your own verification of the transaction details, including the target contract and the function you are calling. This tool is provided free of charge, with no warranty of accuracy or completeness.