Add an oracle for the validation round.

linera-base/src/data_types.rs

@@ -105,7 +105,20 @@ pub struct BlockHeight(pub u64);
 
 /// An identifier for successive attempts to decide a value in a consensus protocol.
 #[derive(
-    Eq, PartialEq, Ord, PartialOrd, Copy, Clone, Hash, Default, Debug, Serialize, Deserialize,
+    Eq,
+    PartialEq,
+    Ord,
+    PartialOrd,
+    Copy,
+    Clone,
+    Hash,
+    Default,
+    Debug,
+    Serialize,
+    Deserialize,
+    WitType,
+    WitLoad,
+    WitStore,
 )]
 pub enum Round {
     /// The initial fast round.
@@ -763,6 +776,8 @@ pub enum OracleResponse {
     Blob(BlobId),
     /// An assertion oracle that passed.
     Assert,
+    /// The block's validation round.
+    Round(Round),
 }
 
 impl Display for OracleResponse {
@@ -774,6 +789,7 @@ impl Display for OracleResponse {
             OracleResponse::Post(bytes) => write!(f, "Post:{}", STANDARD_NO_PAD.encode(bytes))?,
             OracleResponse::Blob(blob_id) => write!(f, "Blob:{}", blob_id)?,
             OracleResponse::Assert => write!(f, "Assert")?,
+            OracleResponse::Round(round) => write!(f, "Round:{round}")?,
         };
 
         Ok(())

linera-chain/src/chain.rs

@@ -13,7 +13,7 @@ use futures::stream::{self, StreamExt, TryStreamExt};
 use linera_base::{
     crypto::CryptoHash,
     data_types::{
-        Amount, ArithmeticError, Blob, BlockHeight, OracleResponse, Timestamp,
+        Amount, ArithmeticError, Blob, BlockHeight, OracleResponse, Round, Timestamp,
         UserApplicationDescription,
     },
     ensure,
@@ -666,6 +666,7 @@ where
         &mut self,
         block: &ProposedBlock,
         local_time: Timestamp,
+        round: Option<Round>,
         replaying_oracle_responses: Option<Vec<Vec<OracleResponse>>>,
     ) -> Result<BlockExecutionOutcome, ChainError> {
         #[cfg(with_metrics)]
@@ -785,6 +786,7 @@ where
                             posted_message,
                             incoming_bundle,
                             block,
+                            round,
                             txn_index,
                             local_time,
                             &mut txn_tracker,
@@ -803,6 +805,7 @@ where
                         chain_id,
                         height: block.height,
                         index: Some(txn_index),
+                        round,
                         authenticated_signer: block.authenticated_signer,
                         authenticated_caller_id: None,
                     };
@@ -935,6 +938,7 @@ where
         posted_message: &PostedMessage,
         incoming_bundle: &IncomingBundle,
         block: &ProposedBlock,
+        round: Option<Round>,
         txn_index: u32,
         local_time: Timestamp,
         txn_tracker: &mut TransactionTracker,
@@ -946,6 +950,7 @@ where
             chain_id: block.chain_id,
             is_bouncing: posted_message.is_bouncing(),
             height: block.height,
+            round,
             certificate_hash: incoming_bundle.bundle.certificate_hash,
             message_id,
             authenticated_signer: posted_message.authenticated_signer,

linera-chain/src/unit_tests/chain_tests.rs

@@ -160,7 +160,7 @@ async fn test_block_size_limit() {
             recipient: Recipient::root(0),
             amount: Amount::ONE,
         });
-    let result = chain.execute_block(&invalid_block, time, None).await;
+    let result = chain.execute_block(&invalid_block, time, None, None).await;
     assert_matches!(
         result,
         Err(ChainError::ExecutionError(
@@ -170,7 +170,10 @@ async fn test_block_size_limit() {
     );
 
     // The valid block is accepted...
-    let outcome = chain.execute_block(&valid_block, time, None).await.unwrap();
+    let outcome = chain
+        .execute_block(&valid_block, time, None, None)
+        .await
+        .unwrap();
     let block = Block::new(valid_block, outcome);
 
     // ...because its size is exactly at the allowed limit.
@@ -231,7 +234,7 @@ async fn test_application_permissions() -> anyhow::Result<()> {
     let invalid_block = make_first_block(chain_id)
         .with_incoming_bundle(bundle.clone())
         .with_simple_transfer(chain_id, Amount::ONE);
-    let result = chain.execute_block(&invalid_block, time, None).await;
+    let result = chain.execute_block(&invalid_block, time, None, None).await;
     assert_matches!(result, Err(ChainError::AuthorizedApplications(app_ids))
         if app_ids == vec![application_id]
     );
@@ -247,7 +250,7 @@ async fn test_application_permissions() -> anyhow::Result<()> {
         .with_incoming_bundle(bundle)
         .with_operation(app_operation.clone());
     let executed_block = chain
-        .execute_block(&valid_block, time, None)
+        .execute_block(&valid_block, time, None, None)
         .await?
         .with(valid_block);
     let value = Hashed::new(ConfirmedBlock::new(executed_block));
@@ -256,14 +259,14 @@ async fn test_application_permissions() -> anyhow::Result<()> {
     let invalid_block = make_child_block(&value.clone())
         .with_simple_transfer(chain_id, Amount::ONE)
         .with_operation(app_operation.clone());
-    let result = chain.execute_block(&invalid_block, time, None).await;
+    let result = chain.execute_block(&invalid_block, time, None, None).await;
     assert_matches!(result, Err(ChainError::AuthorizedApplications(app_ids))
         if app_ids == vec![application_id]
     );
 
     // Also, blocks without an application operation or incoming message are forbidden.
     let invalid_block = make_child_block(&value.clone());
-    let result = chain.execute_block(&invalid_block, time, None).await;
+    let result = chain.execute_block(&invalid_block, time, None, None).await;
     assert_matches!(result, Err(ChainError::MissingMandatoryApplications(app_ids))
         if app_ids == vec![application_id]
     );
@@ -272,7 +275,7 @@ async fn test_application_permissions() -> anyhow::Result<()> {
     application.expect_call(ExpectedCall::execute_operation(|_, _, _| Ok(vec![])));
     application.expect_call(ExpectedCall::default_finalize());
     let valid_block = make_child_block(&value).with_operation(app_operation);
-    chain.execute_block(&valid_block, time, None).await?;
+    chain.execute_block(&valid_block, time, None, None).await?;
 
     Ok(())
 }

linera-client/src/client_context.rs

@@ -33,7 +33,7 @@ use {
     futures::{stream, StreamExt as _, TryStreamExt as _},
     linera_base::{
         crypto::PublicKey,
-        data_types::Amount,
+        data_types::{Amount, Round},
         identifiers::{AccountOwner, ApplicationId, Owner},
     },
     linera_chain::data_types::{
@@ -972,11 +972,12 @@ where
     pub async fn stage_block_execution(
         &self,
         block: ProposedBlock,
+        round: Option<Round>,
     ) -> Result<ExecutedBlock, Error> {
         Ok(self
             .client
             .local_node()
-            .stage_block_execution(block)
+            .stage_block_execution(block, round)
             .await?
             .0)
     }

linera-core/src/chain_worker/actor.rs

@@ -12,7 +12,7 @@ use std::{
 use custom_debug_derive::Debug;
 use linera_base::{
     crypto::CryptoHash,
-    data_types::{Blob, BlockHeight, Timestamp, UserApplicationDescription},
+    data_types::{Blob, BlockHeight, Round, Timestamp, UserApplicationDescription},
     hashed::Hashed,
     identifiers::{BlobId, ChainId, UserApplicationId},
 };
@@ -85,6 +85,7 @@ where
     /// Execute a block but discard any changes to the chain state.
     StageBlockExecution {
         block: ProposedBlock,
+        round: Option<Round>,
         #[debug(skip)]
         callback: oneshot::Sender<Result<(ExecutedBlock, ChainInfoResponse), WorkerError>>,
     },
@@ -286,8 +287,12 @@ where
                 } => callback
                     .send(self.worker.describe_application(application_id).await)
                     .is_ok(),
-                ChainWorkerRequest::StageBlockExecution { block, callback } => callback
-                    .send(self.worker.stage_block_execution(block).await)
+                ChainWorkerRequest::StageBlockExecution {
+                    block,
+                    round,
+                    callback,
+                } => callback
+                    .send(self.worker.stage_block_execution(block, round).await)
                     .is_ok(),
                 ChainWorkerRequest::ProcessTimeout {
                     certificate,

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

@@ -359,6 +359,7 @@ where
         let verified_outcome = Box::pin(self.state.chain.execute_block(
             &executed_block.block,
             local_time,
+            None,
             Some(executed_block.outcome.oracle_responses.clone()),
         ))
         .await?;

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

@@ -13,7 +13,7 @@ use std::{
 
 use linera_base::{
     crypto::CryptoHash,
-    data_types::{Blob, BlockHeight, UserApplicationDescription},
+    data_types::{Blob, BlockHeight, Round, UserApplicationDescription},
     ensure,
     hashed::Hashed,
     identifiers::{BlobId, ChainId, UserApplicationId},
@@ -179,10 +179,11 @@ where
     pub(super) async fn stage_block_execution(
         &mut self,
         block: ProposedBlock,
+        round: Option<Round>,
     ) -> Result<(ExecutedBlock, ChainInfoResponse), WorkerError> {
         ChainWorkerStateWithTemporaryChanges::new(self)
             .await
-            .stage_block_execution(block)
+            .stage_block_execution(block, round)
             .await
     }
 

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

@@ -5,7 +5,7 @@
 
 use linera_base::{
     data_types::{
-        ArithmeticError, Blob, BlobContent, CompressedBytecode, Timestamp,
+        ArithmeticError, Blob, BlobContent, CompressedBytecode, Round, Timestamp,
         UserApplicationDescription,
     },
     ensure,
@@ -126,14 +126,15 @@ where
     /// Executes a block without persisting any changes to the state.
     pub(super) async fn stage_block_execution(
         &mut self,
-        proposal: ProposedBlock,
+        block: ProposedBlock,
+        round: Option<Round>,
     ) -> Result<(ExecutedBlock, ChainInfoResponse), WorkerError> {
         let local_time = self.0.storage.clock().current_time();
-        let signer = proposal.authenticated_signer;
+        let signer = block.authenticated_signer;
 
-        let executed_block = Box::pin(self.0.chain.execute_block(&proposal, local_time, None))
+        let executed_block = Box::pin(self.0.chain.execute_block(&block, local_time, round, None))
             .await?
-            .with(proposal);
+            .with(block);
 
         let mut response = ChainInfoResponse::new(&self.0.chain, None);
         if let Some(signer) = signer {
@@ -238,7 +239,12 @@ where
         let outcome = if let Some(outcome) = outcome {
             outcome.clone()
         } else {
-            Box::pin(self.0.chain.execute_block(block, local_time, None)).await?
+            Box::pin(
+                self.0
+                    .chain
+                    .execute_block(block, local_time, Some(*round), None),
+            )
+            .await?
         };
 
         let executed_block = outcome.with(block.clone());