More complete RevertConfirm requests. (linera-io#5900)

## Motivation

In some cases we send `RevertConfirm` with the lowest height that we
_know_ we are missing.

We should instead request the lowest height we _don't_ know we are _not_
missing, to make it more likely that we really get _all_ events.

## Proposal

Rename the field and request the next expected height.

## Test Plan

CI

## Release Plan

- Hotfix validators
- Port to `main`.

## Links

- [reviewer
checklist](https://github.com/linera-io/linera-protocol/blob/main/CONTRIBUTING.md#reviewer-checklist)

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: afck

linera-core/src/chain_worker/actor.rs

@@ -191,7 +191,7 @@ where
     /// Handle a `RevertConfirm` request to re-add outbox entries and resend bundles.
     HandleRevertConfirm {
         recipient: ChainId,
-        missing_height: BlockHeight,
+        retransmit_from: BlockHeight,
         #[debug(skip)]
         callback: oneshot::Sender<Result<NetworkActions, WorkerError>>,
     },

linera-core/src/chain_worker/state.rs

@@ -104,12 +104,12 @@ pub(crate) enum CrossChainUpdateResult {
     Updated(BlockHeight),
     /// All bundles were already received; nothing to do.
     NothingToDo,
-    /// A gap was detected: the inbox expected a bundle at `missing_height` from `origin`
-    /// but received a bundle at a higher height. If `allow_revert_confirm` is enabled,
-    /// a `RevertConfirm` request should be sent.
+    /// A gap was detected in the inbox for messages from `origin`. If
+    /// `allow_revert_confirm` is enabled, a `RevertConfirm` request should be sent
+    /// to retransmit bundles starting from `retransmit_from`.
     GapDetected {
         origin: ChainId,
-        missing_height: BlockHeight,
+        retransmit_from: BlockHeight,
     },
 }
 
@@ -260,10 +260,10 @@ where
                 .is_ok(),
             ChainWorkerRequest::HandleRevertConfirm {
                 recipient,
-                missing_height,
+                retransmit_from,
                 callback,
             } => callback
-                .send(self.handle_revert_confirm(recipient, missing_height).await)
+                .send(self.handle_revert_confirm(recipient, retransmit_from).await)
                 .is_ok(),
             ChainWorkerRequest::HandleChainInfoQuery { query, callback } => callback
                 .send(self.handle_chain_info_query(query).await)
@@ -1055,22 +1055,21 @@ where
             .await
         {
             Ok(()) => {}
-            Err(ChainError::InboxGapDetected {
-                origin,
-                expected_height,
-                ..
-            }) if self.config.allow_revert_confirm => {
+            Err(ChainError::InboxGapDetected { origin, .. })
+                if self.config.allow_revert_confirm =>
+            {
+                let retransmit_from = self.get_inbox_next_height(origin).await?;
                 warn!(
                     "Inbox gap detected for {chain_id} from {origin}: \
-                    missing height {expected_height}; requesting resend",
+                    requesting resend from {retransmit_from}",
                 );
                 let mut actions = NetworkActions::default();
                 actions
                     .cross_chain_requests
                     .push(CrossChainRequest::RevertConfirm {
                         sender: origin,
                         recipient: chain_id,
-                        missing_height: expected_height,
+                        retransmit_from,
                     });
                 return Ok((self.chain_info_response(), actions, BlockOutcome::Skipped));
             }
@@ -1223,7 +1222,7 @@ where
                     );
                     return Ok(CrossChainUpdateResult::GapDetected {
                         origin,
-                        missing_height: prev,
+                        retransmit_from: next_height_to_receive,
                     });
                 }
                 return Err(ChainError::InboxGapDetected {
@@ -1267,18 +1266,18 @@ where
                 .await
             {
                 Ok(()) => {}
-                Err(ChainError::InboxGapDetected {
-                    expected_height, ..
-                }) if self.config.allow_revert_confirm => {
+                Err(ChainError::InboxGapDetected { .. }) if self.config.allow_revert_confirm => {
                     // Don't save — leave the inbox unchanged so the resend can
-                    // reconcile properly.
+                    // reconcile properly. Request from next_height_to_receive
+                    // rather than the specific gap height, so that all pending
+                    // removed_bundles entries can also be reconciled.
                     warn!(
                         "Inbox gap detected for {recipient} from {origin}: \
-                        missing height {expected_height}; requesting resend",
+                        requesting resend from {next_height_to_receive}",
                     );
                     return Ok(CrossChainUpdateResult::GapDetected {
                         origin,
-                        missing_height: expected_height,
+                        retransmit_from: next_height_to_receive,
                     });
                 }
                 Err(e) => return Err(e.into()),
@@ -1336,28 +1335,28 @@ where
 
     /// Handles a `RevertConfirm` request: walks backward through
     /// `previous_message_blocks` to find all block heights that sent messages to
-    /// `recipient` starting from the latest down to `missing_height`, re-adds them
+    /// `recipient` starting from the latest down to `retransmit_from`, re-adds them
     /// to the outbox, and creates cross-chain update actions to resend the bundles.
     #[instrument(skip_all, fields(
         chain_id = %self.chain_id(),
-        recipient = %recipient,
-        missing_height = %missing_height,
+        %recipient,
+        %retransmit_from,
     ))]
     pub(super) async fn handle_revert_confirm(
         &mut self,
         recipient: ChainId,
-        missing_height: BlockHeight,
+        retransmit_from: BlockHeight,
     ) -> Result<NetworkActions, WorkerError> {
         // 1. Walk backward through previous_message_blocks to collect all heights
-        //    that sent messages to this recipient, from the latest down to missing_height.
+        //    that sent messages to this recipient, from the latest down to retransmit_from.
         let Some(latest_height) = self.chain.previous_message_blocks.get(&recipient).await? else {
             warn!("RevertConfirm: no record of sending to {recipient}");
             return Ok(NetworkActions::default());
         };
 
         let mut heights_to_re_add = Vec::new();
         let mut current_height = latest_height;
-        while current_height >= missing_height {
+        while current_height >= retransmit_from {
             // We arrived at current_height via previous_message_blocks links, starting from the
             // chain state and following the links downwards. So these blocks should all be in
             // confirmed_log or preprocessed_blocks already.
@@ -1381,7 +1380,7 @@ where
                     chain_id: self.chain_id(),
                 })?;
             match block.block().body.previous_message_blocks.get(&recipient) {
-                Some((_, prev_height)) if *prev_height >= missing_height => {
+                Some((_, prev_height)) if *prev_height >= retransmit_from => {
                     current_height = *prev_height;
                 }
                 _ => break,
@@ -1419,7 +1418,7 @@ where
 
         warn!(
             "RevertConfirm: re-added {new_heights_len} heights to outbox for {recipient}, \
-            starting from height {missing_height}"
+            starting from height {retransmit_from}"
         );
 
         Ok(actions)
@@ -1486,7 +1485,7 @@ where
                 .push(CrossChainRequest::RevertConfirm {
                     sender: sender_id,
                     recipient: chain_id,
-                    missing_height: BlockHeight::ZERO,
+                    retransmit_from: BlockHeight::ZERO,
                 });
         }
 

linera-core/src/data_types.rs

@@ -267,7 +267,7 @@ pub enum CrossChainRequest {
     RevertConfirm {
         sender: ChainId,
         recipient: ChainId,
-        missing_height: BlockHeight,
+        retransmit_from: BlockHeight,
     },
 }
 

linera-core/src/worker.rs

@@ -1362,14 +1362,14 @@ where
                     }
                     CrossChainUpdateResult::GapDetected {
                         origin,
-                        missing_height,
+                        retransmit_from,
                     } => {
                         actions
                             .cross_chain_requests
                             .push(CrossChainRequest::RevertConfirm {
                                 sender: origin,
                                 recipient,
-                                missing_height,
+                                retransmit_from,
                             });
                     }
                 }
@@ -1394,12 +1394,12 @@ where
             CrossChainRequest::RevertConfirm {
                 sender,
                 recipient,
-                missing_height,
+                retransmit_from,
             } => {
                 self.query_chain_worker(sender, move |callback| {
                     ChainWorkerRequest::HandleRevertConfirm {
                         recipient,
-                        missing_height,
+                        retransmit_from,
                         callback,
                     }
                 })

linera-rpc/proto/rpc.proto

@@ -217,7 +217,7 @@ message ConfirmUpdatedRecipient {
 message RevertConfirm {
   ChainId sender = 1;
   ChainId recipient = 2;
-  BlockHeight missing_height = 3;
+  BlockHeight retransmit_from = 3;
 }
 
 // Request information on a chain.

linera-rpc/src/grpc/conversions.rs

@@ -308,11 +308,11 @@ impl TryFrom<api::CrossChainRequest> for CrossChainRequest {
             Inner::RevertConfirm(api::RevertConfirm {
                 sender,
                 recipient,
-                missing_height,
+                retransmit_from,
             }) => CrossChainRequest::RevertConfirm {
                 sender: try_proto_convert(sender)?,
                 recipient: try_proto_convert(recipient)?,
-                missing_height: missing_height
+                retransmit_from: retransmit_from
                     .ok_or(GrpcProtoConversionError::MissingField)?
                     .into(),
             },
@@ -351,11 +351,11 @@ impl TryFrom<CrossChainRequest> for api::CrossChainRequest {
             CrossChainRequest::RevertConfirm {
                 sender,
                 recipient,
-                missing_height,
+                retransmit_from,
             } => Inner::RevertConfirm(api::RevertConfirm {
                 sender: Some(sender.into()),
                 recipient: Some(recipient.into()),
-                missing_height: Some(missing_height.into()),
+                retransmit_from: Some(retransmit_from.into()),
             }),
         };
         Ok(Self { inner: Some(inner) })

linera-rpc/tests/snapshots/format__format.yaml.snap

@@ -498,7 +498,7 @@ CrossChainRequest:
               TYPENAME: ChainId
           - recipient:
               TYPENAME: ChainId
-          - missing_height:
+          - retransmit_from:
               TYPENAME: BlockHeight
 CryptoHash:
   NEWTYPESTRUCT: