[tesseract]: greedily select rotation proofs the destination can verify

A stored rotation proof keyed K is a BEEFY commitment signed by the outgoing
set (validatorSetId = K-1) whose leaf reveals K+1. A destination only accepts a
commitment signed by its on-chain current or next set, so a destination that has
skipped a set (next > current+1, e.g. BSC current=5071/next=5073) cannot verify
keyed-(next) — it is signed by next-1, which it never saw — and reverts with
UnknownAuthoritySet.

Replace the single-offset anchor with a greedy walk of the destination state:
applying keyed-K to {cur,nxt} yields {nxt,K+1}, so pick keyed-(cur+1) when
contiguous (advance by one, no skip) and keyed-(nxt+1) when gapped (signed by
nxt; advances, stepping over sets that can no longer be installed). Stop when the
next needed proof hasn't been produced on HB yet and continue on a later tick.

rotation_proofs_from now returns all stored proofs above `from` and no longer
errors on a missing immediate-next entry; the caller decides what it needs.

Author: Wizdave97

tesseract/messaging/messaging/src/outbound.rs

@@ -712,33 +712,57 @@ async fn catch_up_rotations(
 		return Ok(Vec::new());
 	}
 
-	// Anchor the catch-up on the destination's on-chain `next` set id, not its `current`.
-	// A destination can only verify a consensus proof signed by an authority set it holds
-	// on-chain — its `current` or its `next` set. When it has skipped intermediate sets
-	// (its `next` is more than one ahead of `current`, e.g. current=5071/next=5073 with
-	// 5072 never installed because an applied proof's MMR leaf jumped the next-set id), a
-	// rotation proof for one of those skipped sets (5072) is signed by an authority set the
-	// destination has never seen and reverts on-chain with `UnknownAuthoritySet`. Fetching
-	// rotations strictly above `dest_next_id - 1` yields only set ids `>= dest_next_id`, so
-	// the first proof we submit is the one signed by the destination's `next` set — the
-	// smallest set id it can actually accept. In the common contiguous case
-	// (`next == current + 1`) this is identical to anchoring on `current`.
-	let anchor = dest_next_id.saturating_sub(1).max(dest_set_id);
-	let rotations: Vec<RotationProof> = proof_source
-		.rotation_proofs_from(anchor)
+	// Greedily walk the destination forward, picking only rotation proofs it can actually verify
+	// and that advance its state. A stored rotation proof keyed `K` is a BEEFY commitment signed
+	// by `validatorSetId = K - 1` (the outgoing set) whose MMR leaf reveals the next set `K + 1`.
+	// The destination's verifier accepts a commitment only if its `validatorSetId` is the
+	// destination's on-chain `current` or `next` set, and it rotates (`current <- next`,
+	// `next <- leaf.next`) only when the leaf is beyond the current `next`.
+	//
+	// Applying keyed-`K` to `{cur, nxt}` (which needs `K-1 ∈ {cur, nxt}` and `K+1 > nxt`) yields
+	// `{nxt, K+1}`. So from a contiguous state we pick keyed-`cur+1` (signed by `cur`) and stay
+	// contiguous — no authority set is skipped. From a state that has already leap-frogged a set
+	// (`nxt > cur + 1`, e.g. BSC at current=5071/next=5073) the only acceptable advancing proof is
+	// keyed-`nxt+1` (signed by `nxt`); the skipped sets can never be re-installed, so progress
+	// there steps over them. Submitting keyed-`nxt` (signed by `nxt-1`) — the previous anchor —
+	// reverts with `UnknownAuthoritySet` for such a destination, which is the bug this replaces.
+	let by_set_id: BTreeMap<u64, RotationProof> = proof_source
+		.rotation_proofs_from(dest_set_id)
 		.await
-		.map_err(|err| anyhow::anyhow!("rotation_proofs_from({anchor}): {err:?}"))?;
-	if rotations.is_empty() {
-		return Err(anyhow!("dest is lagging but no rotation proofs are cached on HB"));
+		.map_err(|err| anyhow::anyhow!("rotation_proofs_from({dest_set_id}): {err:?}"))?
+		.into_iter()
+		.map(|r| (r.set_id, r))
+		.collect();
+
+	let mut cur = dest_set_id;
+	let mut nxt = dest_next_id;
+	let mut rotations: Vec<RotationProof> = Vec::new();
+	while cur < hb_set_id {
+		// Contiguous → advance by one (no skip); gapped → advance to `nxt` (forced skip).
+		let key = if nxt == cur + 1 { cur + 1 } else { nxt + 1 };
+		let Some(proof) = by_set_id.get(&key) else {
+			// The next proof the destination needs hasn't been produced on HB yet (HB hasn't
+			// rotated that far). Stop; a later tick continues once it's available.
+			break;
+		};
+		// The main batch delivers `current_set_id` itself via its `consensus_msg`, so don't
+		// double-submit it — but the destination still advances past it either way.
+		if Some(key) != current_set_id {
+			rotations.push(proof.clone());
+		}
+		cur = nxt;
+		nxt = key + 1;
 	}
 
-	// Drop the rotation that matches the current notification's set_id —
-	// the main batch will submit that one via its `consensus_msg`. Without
-	// this filter the same proof would land twice on the destination: once
-	// here, once via the main batch.
-	let rotations: Vec<RotationProof> =
-		rotations.into_iter().filter(|r| Some(r.set_id) != current_set_id).collect();
 	if rotations.is_empty() {
+		tracing::debug!(
+			target: LOG_TARGET,
+			dest = %dest_name,
+			dest_set_id,
+			dest_next_id,
+			hb_set_id,
+			"dest is behind but no applicable rotation proof is available yet; waiting",
+		);
 		return Ok(Vec::new());
 	}
 

tesseract/relayer/src/provider.rs

@@ -105,12 +105,9 @@ impl ConsensusProofSource for OffchainProofSource {
 		let map: BTreeMap<u64, u64> = Decode::decode(&mut &bytes[..])
 			.map_err(|err| anyhow!("decode RotationProofs BTreeMap: {err:?}"))?;
 
-		let next_set_id = from_set_id + 1;
-		if !map.contains_key(&next_set_id) {
-			return Err(anyhow!(
-				"RotationProofs missing entry for set_id {next_set_id} (catching up from {from_set_id})"
-			));
-		}
+		// Return whatever is stored above `from_set_id`; the caller greedily selects the subset
+		// the destination can actually verify and apply. A missing immediate-next entry is not
+		// fatal here — the caller decides whether the keys it needs are present.
 
 		// Walk ascending so the caller can submit rotations in order.
 		let mut out = Vec::new();