[Claudius-Maginificent]

TL;DR: A validator that fell behind can now get the block the network already agreed to vote on, and process it, so it can rejoin the round instead of leaving the network stuck.

User story

As a validator operator, I want a validator that missed a block to fetch and process it from its peers, to achieve continued block production after network trouble or validator outages.

Scenario

Base flow

In each round a proposer sends a block. Once more than two-thirds of validators prevote for it (a "polka"), validators precommit it. Precommits for a block carry vote extensions, which the application (Drive) checks before the vote is counted.

Actual behavior

Take a validator that saw a polka for a block but never received the block itself:

• Its peers move on to the next round and stop sending that block's parts.
• Even when the block does arrive late, the validator never hands it to the application.
• The application therefore keeps rejecting the vote extensions in other validators' precommits for that block. Those votes are not counted, no timer starts, and the validator stays in the old round.

If the validators that went ahead cannot reach a two-thirds quorum without the stuck ones, the whole network stalls. Two ways to get there:

• about one-third of validators stop voting after the polka;
• about one-third crash at the same moment while another third is cut off from the block.

Expected behavior

Validators that still hold the agreed block send it to peers that ask for it. A validator that completes the block processes it, accepts the other validators' precommits, starts its timer and rejoins the round. With the round back at a two-thirds quorum, the network commits the block.

Detailed discussion

What was done

• Serving the polka block (gossip_handlers.go, heldBlockPartsFor):
  • Data gossip normally serves parts only from rs.ProposalBlockParts, which entering a new round clears. A node then still holds the polka block as ValidBlockParts and/or LockedBlockParts, but those were never served.
  • When the normal path sends nothing, a complete ValidBlockParts or LockedBlockParts is now served to a peer that meets all of these:
    • it is a validator,
    • it is at the same height, in an earlier round,
    • its requested ProposalBlockPartSetHeader equals the held one exactly (header equality is the block identity).
  • The handler repoints only its local snapshot copy (ProposalBlockParts, and Round to the peer's round so SetHasProposalBlockPart marks the parts) and calls the existing GossipProposalBlockParts.
  • Consensus state is never mutated. Same-round peers never reach this branch.
• Processing the polka block (state_add_prop_block.go, ProposalCompletedAction.processPolkaBlock):
  • Today a block completed in the Prevote or Precommit steps is never passed to ProcessProposal.
  • Now, when the completed block equals the non-nil +2/3 prevote majority of the node's current round and has not been processed for that round, it is processed via ensureProcess(rs, rs.Round).
  • No vote is cast or changed.
  • It runs once per block completion, so the per-precommit path has no extra cost. A failure is logged and not retried.
  • ensureOwnRound then finds the round processed, and VerifyVoteExtension accepts the peers' precommits.
  • ProposalCompletedAction gets the blockExec dependency (state_controller.go).
• Dependency on fix(consensus): resend same-round votes the peer never acknowledged #1599 for consensus v1:
  • Precommits the lagging node rejected before it had the block must be delivered again. Optimistic vote gossip never resends them.
  • fix(consensus): resend same-round votes the peer never acknowledged #1599 re-offers unacknowledged votes, which covers this on all consensus versions.
  • On consensus v2, roundVoteResendGossipHandler from feat(consensus)!: hand a silent proposer's idle round to the next proposer #1572 already resends the earlier round's precommits.
  • On v1, this PR ends the stall only together with fix(consensus): resend same-round votes the peer never acknowledged #1599.

Testing

• New tests:

  Test	Kind
  TestGossipHandlerTestSuite/TestDataGossipHandlerServesHeldBlockToLaggingPeer	Serves the valid block, the locked block, and the valid block while the round proposes another. Negative cases: mismatched header, other height, same/later round, non-validator, incomplete part set.
  TestStatePolkaBlockCompletedInPrecommitIsProcessed	Fails without the fix.
  TestStatePolkaBlockDeliveryEndsThePrecommitStall	Fails without the fix. Ends with TriggeredTimeoutPrecommit.
  TestStatePolkaBlockRejectedByTheApplicationIsNotRetried	Fails without the fix.
  TestStatePolkaBlockCompletedInPrevoteWaitIsProcessedOnce	Fails without the fix.
  TestStatePolkaBlockCompletedInProposeVotesAndProcessesOnce	Regression guard.
  TestStateCompletedBlockWithoutItsPolkaIsNotProcessed	Regression guard.
  TestStateCompletedBlockOtherThanThePolkaBlockIsNotProcessed	Regression guard; a mutation check confirms it catches removal of the block-identity check.

• The tests use a Drive-like application that accepts extensions only for a processed (height, round, hash).

• The new tests also pass under -race. A regression subset (lock, full-round, proposal, prevote/precommit, gossip, commit-extension and reactor tests) passes, and make lint reports 0 issues.

• An independent review found:

  • the v1 dependency on fix(consensus): resend same-round votes the peer never acknowledged #1599 (documented above);
  • missing edge-case tests, now added.

Breaking changes

None.

Prior work

• fix(consensus): resend same-round votes the peer never acknowledged #1599: vote redelivery. Required for this fix to be complete on consensus v1; the two merge cleanly.
• fix(consensus): periodically re-announce round state to peers #1598: periodic round-step re-announcement, so peers keep an accurate view of this node's round. The two merge cleanly.
• feat(consensus)!: hand a silent proposer's idle round to the next proposer #1572 (merged): its round vote resend covers precommit redelivery on consensus v2.
• fix(consensus): resend catch-up block parts to prevent lagging-peer wedge #1365: fixed the analogous "never resent" wedge for catch-up block parts.

Attribution

🤖 Generated with Claude Code

https://claude.ai/code/session_01WunYYgcoPDNh3uebhUCwig

_{🤖 Co-authored by Claudius the Magnificent AI Agent}

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on this repository. Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

Run configuration

• Source mode: Auto
• Repository: dashpay/tenderdash
• Branch: fix/consensus-serve-polka-block
• File: .coderabbit.yaml
• Commit: 2cc8d96
• Layers: Repository YAML
• Review profile: CHILL
• Plan: Advanced
• Run ID: e5557381-37bb-4c4e-b4f8-ba321e7a4da0

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• Trigger review

• Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

Share

• X
• Mastodon
• Reddit
• LinkedIn

[thepastaclaw]

🕓 Review not started yet because this PR is a draft.

• Request normal review — click when the PR is ready for review.
• Request priority review — click to move this review to the front of the queue.

Commit 2cc8d96. Normal review starts when eligible; priority review starts as soon as a slot is available.