No oracles in fast blocks; automatically propose a regular block if oracles. (#2977)

* Automatically propose a regular block if there is an oracle call.

* Disallow all oracles in fast blocks.

* Improve comment.

Author: afck

linera-base/src/data_types.rs

@@ -761,13 +761,6 @@ pub enum OracleResponse {
     Assert,
 }
 
-impl OracleResponse {
-    /// Wether an `OracleResponse` is permitted in fast blocks or not.
-    pub fn is_permitted_in_fast_blocks(&self) -> bool {
-        matches!(self, OracleResponse::Blob(_))
-    }
-}
-
 impl Display for OracleResponse {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

linera-chain/src/data_types.rs

@@ -728,6 +728,12 @@ impl BlockExecutionOutcome {
 
         required_blob_ids
     }
+
+    pub fn has_oracle_responses(&self) -> bool {
+        self.oracle_responses
+            .iter()
+            .any(|responses| !responses.is_empty())
+    }
 }
 
 /// The data a block proposer signs.

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

@@ -240,16 +240,10 @@ where
                 .with_value(value)
                 .ok_or_else(|| WorkerError::InvalidLiteCertificate)?;
         }
-        if round.is_fast() {
-            ensure!(
-                outcome
-                    .oracle_responses
-                    .iter()
-                    .flatten()
-                    .all(|response| response.is_permitted_in_fast_blocks()),
-                WorkerError::FastBlockUsingOracles
-            );
-        }
+        ensure!(
+            !round.is_fast() || !outcome.has_oracle_responses(),
+            WorkerError::FastBlockUsingOracles
+        );
         // Check if the counters of tip_state would be valid.
         self.0
             .chain

linera-core/src/client/mod.rs

@@ -2352,7 +2352,7 @@ where
         };
 
         let identity = self.identity().await?;
-        let round = match Self::round_for_new_proposal(&info, &identity, &executed_block.block)? {
+        let round = match Self::round_for_new_proposal(&info, &identity, &executed_block)? {
             Either::Left(round) => round,
             Either::Right(timeout) => return Ok(ClientOutcome::WaitForTimeout(timeout)),
         };
@@ -2442,20 +2442,23 @@ where
     fn round_for_new_proposal(
         info: &ChainInfo,
         identity: &Owner,
-        block: &Block,
+        executed_block: &ExecutedBlock,
     ) -> Result<Either<Round, RoundTimeout>, ChainClientError> {
+        let manager = &info.manager;
+        let block = &executed_block.block;
         // If there is a conflicting proposal in the current round, we can only propose if the
         // next round can be started without a timeout, i.e. if we are in a multi-leader round.
-        let manager = &info.manager;
-        let conflicting_proposal = manager.requested_proposed.as_ref().is_some_and(|proposal| {
+        // Similarly, we cannot propose a block that uses oracles in the fast round.
+        let conflict = manager.requested_proposed.as_ref().is_some_and(|proposal| {
             proposal.content.round == manager.current_round && proposal.content.block != *block
-        });
-        let round = if !conflicting_proposal {
+        }) || (manager.current_round.is_fast()
+            && executed_block.outcome.has_oracle_responses());
+        let round = if !conflict {
             manager.current_round
         } else if let Some(round) = manager
             .ownership
             .next_round(manager.current_round)
-            .filter(|_| manager.current_round.is_multi_leader())
+            .filter(|_| manager.current_round.is_multi_leader() || manager.current_round.is_fast())
         {
             round
         } else if let Some(timeout) = info.round_timeout() {

linera-core/src/unit_tests/client_tests.rs

@@ -2432,6 +2432,18 @@ where
     let client2 = builder.add_initial_chain(description2, Amount::ONE).await?;
     let client3 = builder.add_initial_chain(description3, Amount::ONE).await?;
 
+    // Configure the clients as super owners, so they make fast blocks by default.
+    for client in [&client1, &client2, &client3] {
+        let pub_key = client.public_key().await?;
+        let owner_change_op = Operation::System(SystemOperation::ChangeOwnership {
+            super_owners: vec![pub_key],
+            owners: vec![],
+            multi_leader_rounds: 10,
+            timeout_config: TimeoutConfig::default(),
+        });
+        client.execute_operation(owner_change_op.clone()).await?;
+    }
+
     // Take one validator down
     builder.set_fault_type([3], FaultType::Offline).await;
 
@@ -2440,19 +2452,21 @@ where
         CryptoHash::new(&BlobBytes(blob_bytes.clone())),
         BlobType::Data,
     );
-    client1
+    let certificate = client1
         .publish_data_blob(blob_bytes)
         .await
         .unwrap()
         .unwrap();
+    assert_eq!(certificate.round, Round::Fast);
 
     // Send a message from chain 2 to chain 3.
-    client2
+    let certificate = client2
         .transfer(None, Amount::from_millis(1), Recipient::chain(chain_id3))
         .await
         .unwrap()
         .unwrap();
     client3.synchronize_from_validators().await.unwrap();
+    assert_eq!(certificate.round, Round::Fast);
 
     builder.set_fault_type([2], FaultType::Offline).await;
     builder.set_fault_type([3], FaultType::Honest).await;
@@ -2463,6 +2477,8 @@ where
         .await
         .unwrap()
         .unwrap();
+    // This read a new blob, so it cannot be a fast block.
+    assert_eq!(certificate.round, Round::MultiLeader(0));
     let executed_block = certificate.executed_block();
     assert_eq!(executed_block.block.incoming_bundles.len(), 1);
     assert_eq!(executed_block.required_blob_ids().len(), 1);