Include the outcome in a re-proposal instead of re-executing. (#3016)

linera-chain/src/data_types.rs

@@ -743,18 +743,17 @@ pub struct ProposalContent {
     pub block: Block,
     /// The consensus round in which this proposal is made.
     pub round: Round,
-    /// If this is a retry from an earlier round, the oracle responses from when the block was
-    /// first validated. These are reused so the execution outcome remains the same.
+    /// If this is a retry from an earlier round, the execution outcome.
     #[debug(skip_if = Option::is_none)]
-    pub forced_oracle_responses: Option<Vec<Vec<OracleResponse>>>,
+    pub outcome: Option<BlockExecutionOutcome>,
 }
 
 impl BlockProposal {
     pub fn new_initial(round: Round, block: Block, secret: &KeyPair, blobs: Vec<Blob>) -> Self {
         let content = ProposalContent {
             round,
             block,
-            forced_oracle_responses: None,
+            outcome: None,
         };
         let signature = Signature::new(&content, secret);
         Self {
@@ -777,7 +776,7 @@ impl BlockProposal {
         let content = ProposalContent {
             block: executed_block.block,
             round,
-            forced_oracle_responses: Some(executed_block.outcome.oracle_responses),
+            outcome: Some(executed_block.outcome),
         };
         let signature = Signature::new(&content, secret);
         Self {

linera-core/src/chain_worker/state/temporary_changes.rs

@@ -156,18 +156,18 @@ where
                 ProposalContent {
                     block,
                     round,
-                    forced_oracle_responses,
+                    outcome,
                 },
             owner,
             blobs,
             validated_block_certificate,
             signature: _,
         } = proposal;
         ensure!(
-            validated_block_certificate.is_some() == forced_oracle_responses.is_some(),
+            validated_block_certificate.is_some() == outcome.is_some(),
             WorkerError::InvalidBlockProposal(
                 "Must contain a validation certificate if and only if \
-                 oracle responses are forced from a previous round"
+                 it contains the execution outcome from a previous round"
                     .to_string()
             )
         );
@@ -226,12 +226,11 @@ where
         );
         self.0.storage.clock().sleep_until(block.timestamp).await;
         let local_time = self.0.storage.clock().current_time();
-        let outcome = Box::pin(self.0.chain.execute_block(
-            block,
-            local_time,
-            forced_oracle_responses.clone(),
-        ))
-        .await?;
+        let outcome = if let Some(outcome) = outcome {
+            outcome.clone()
+        } else {
+            Box::pin(self.0.chain.execute_block(block, local_time, None)).await?
+        };
 
         let executed_block = outcome.with(block.clone());
         let required_blobs = self

linera-rpc/src/grpc/conversions.rs

@@ -1104,14 +1104,12 @@ pub mod tests {
     #[test]
     pub fn test_block_proposal() {
         let key_pair = KeyPair::generate();
+        let outcome = BlockExecutionOutcome {
+            state_hash: CryptoHash::new(&Foo("validated".into())),
+            ..BlockExecutionOutcome::default()
+        };
         let cert = ValidatedBlockCertificate::new(
-            Hashed::new(ValidatedBlock::new(
-                BlockExecutionOutcome {
-                    state_hash: CryptoHash::new(&Foo("validated".into())),
-                    ..BlockExecutionOutcome::default()
-                }
-                .with(get_block()),
-            )),
+            Hashed::new(ValidatedBlock::new(outcome.clone().with(get_block()))),
             Round::SingleLeader(2),
             vec![(
                 ValidatorName::from(key_pair.public()),
@@ -1124,7 +1122,7 @@ pub mod tests {
             content: ProposalContent {
                 block: get_block(),
                 round: Round::SingleLeader(4),
-                forced_oracle_responses: Some(Vec::new()),
+                outcome: Some(outcome),
             },
             owner: Owner::from(KeyPair::generate().public()),
             signature: Signature::new(&Foo("test".into()), &KeyPair::generate()),

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

@@ -719,11 +719,9 @@ ProposalContent:
         TYPENAME: Block
     - round:
         TYPENAME: Round
-    - forced_oracle_responses:
+    - outcome:
         OPTION:
-          SEQ:
-            SEQ:
-              TYPENAME: OracleResponse
+          TYPENAME: BlockExecutionOutcome
 PublicKey:
   NEWTYPESTRUCT:
     TUPLEARRAY: