What a Polygon Withdrawal Checkpoint Proves

A Polygon withdrawal checkpoint is a commitment recorded on Ethereum that lets the bridge verify a Polygon PoS transaction belongs to a particular set of blocks. It is one part of a withdrawal, not the transfer itself: first the bridged tokens are burned on Polygon, then a proof tied to a checkpoint can be used to release the matching asset on Ethereum.

The fuller explanation of how Polygon Bridge transfers work covers the wider deposit and withdrawal flow. Here, the key point is that a checkpoint gives Ethereum’s bridge contracts a verifiable reference for activity recorded on Polygon.

What does a Polygon checkpoint contain?

A checkpoint summarizes a range of Polygon PoS block headers in a Merkle root, a compact value that can be checked against proofs of individual blocks. Polygon’s Bor layer produces blocks and transactions. Heimdall coordinates validator activity, including the creation and submission of checkpoints. Validators sign the checkpoint, and it is submitted to a checkpoint contract on Ethereum.

The root does not list every transaction. Instead, it commits to the block headers in its range. A Merkle proof can then show that a particular block header belongs to that range without sending Ethereum the full set of headers. That is what makes the checkpoint useful for withdrawals: it gives the Ethereum contract a trusted reference against which to verify a burn’s block.

Think of it as a sealed index for a batch of blocks. The seal does not describe every page, but it lets a verifier check that a particular page was part of that batch.

How does a checkpoint let a withdrawal complete?

The withdrawal moves through several linked steps. The checkpoint sits between the burn on Polygon and the release on Ethereum.

• Burn on Polygon. The holder starts a withdrawal through the bridge. The relevant Polygon token contract burns the bridged tokens and emits a transaction receipt recording the event.
• Include the block in a checkpoint. Validators submit a checkpoint covering the Polygon block that contains the burn. Until that happens, the Ethereum contract has no checkpointed block against which to verify the withdrawal.
• Build the exit proof. The proof ties the burn receipt to its Polygon block, then ties that block to the checkpoint root. The receipt shows what happened; the Merkle proofs show where it happened.
• Exit on Ethereum. The user submits the proof to the bridge’s Ethereum contract. If the proof checks out and the withdrawal has not already been claimed, the contract releases the corresponding asset.

The checkpoint is therefore an input to verification, not a payment instruction. It does not itself move tokens, create the burn, or complete the exit. The proof connects the burn to the committed block range, while the Ethereum contract checks the proof and processes the release.

What should a withdrawing user check?

After the burn transaction confirms on Polygon, the practical wait is often for a checkpoint to cover its block. Once it does, the exit proof can be assembled and submitted on Ethereum. A withdrawal can therefore have a confirmed burn and still be incomplete: the Ethereum-side release requires its own proof submission and transaction.

Check the status of the burn and whether its block has been checkpointed before trying to exit. Then confirm that the proof and destination refer to the intended withdrawal. The final Ethereum transaction also requires an Ethereum wallet and enough ETH to pay its network fee. Treat the burn confirmation and the completed exit as separate milestones.

For most users, the useful mental model is simple: the burn records the withdrawal on Polygon; the checkpoint commits the relevant block range to Ethereum; the proof lets the Ethereum contract verify the burn; and the exit transaction releases the asset. A checkpoint explains why the withdrawal has a waiting stage, and why that stage alone does not mean the funds have arrived.