# CCIP Message Status and Recovery Checklist for DApp Teams

Canonical: https://dappweb.ai/resources/ccip-message-status-checklist/
Language: en
Published: 2026-11-07

A builder checklist for separating CCIP source send, offchain verification and indexing, and destination execution—plus safe recovery from retryable failures.

> Independent DappWeb engineering note based on public Chainlink documentation. Not an official Chainlink artifact, a live CCIP integration, a security audit, or a report about any named application.

## Keep the four lifecycle phases distinct

The official CCIP 2.0 message lifecycle describes Send on the source chain, Verify by offchain attestations, Index to collect verifier data, and Execute on the destination chain. A status UI should tell users which phase it has actually observed; a source transaction and a destination execution result are different evidence.

Do not map an API status, executor view, verifier result, and onchain execution enum into one undocumented “pending” value. Keep each source and its timestamp visible to support teams.

## Show the destination OffRamp state separately

| OffRamp state | Value | Application meaning |
| --- | ---: | --- |
| `UNTOUCHED` | 0 | No destination execution has been recorded. This does not by itself prove failure or readiness. |
| `IN_PROGRESS` | 1 | A destination execution attempt is running. |
| `SUCCESS` | 2 | Execution completed. Treat this as final and do not offer replay. |
| `FAILURE` | 3 | Destination execution reverted. Diagnose the recorded error and address the cause before retrying. |

`UNTOUCHED` can describe a message that has not run, a missing required verifier entry in the indexer, or an expired automatic-execution retry window. Check required execution inputs before presenting manual execution as ready.

`FAILURE` does not automatically mean the receiver contract is wrong. Possible causes include receiver logic or gas, token handling, missing verifier data, an invalid manual submission, or insufficient outer transaction gas.

## A practical readback sequence

1. Keep the source transaction hash and CCIP message ID together.
2. Use the CCIP API’s message, executor, and verifier fields as diagnostic signals. Treat `readyForManualExecution` as a convenience signal, not final onchain state.
3. Read `OffRamp.getExecutionState(messageId)` after every execution attempt.
4. Retain `ExecutionStateChanged` history when a failure is followed by a successful retry.
5. Present a recovery action only after the message and its required execution inputs have been checked.

A successful outer transaction receipt alone may not tell the full story. Check the destination execution state and recorded error or event history before displaying “delivered.”

## Application acceptance checklist

- Show source chain, destination chain, message ID, and source transaction reference.
- Label source confirmation, verification/indexer progress, and destination execution separately.
- Do not label `UNTOUCHED` as `FAILURE` without additional evidence.
- Do not expose replay after `SUCCESS`.
- For `FAILURE`, show the recorded error and require the cause and execution inputs to be rechecked before retry.
- Distinguish automatic execution from an application-side recovery action.

## Interactive simulation

Open the [local CCIP status walkthrough](https://dappweb.ai/resources/ccip-message-status-checklist/demo/). It uses synthetic values only and makes no RPC, wallet, CCIP API, or contract calls.

## References

- [CCIP Message Lifecycle](https://docs.chain.link/ccip/concepts/message-lifecycle)
- [CCIP Manual Execution](https://docs.chain.link/ccip/concepts/manual-execution)
- [CCIP Service Responsibility](https://docs.chain.link/ccip/concepts/service-responsibility)
- [DappWeb Chainlink X Card](https://dappweb.ai/x-cards/card/chainlink-integration/)
