[DAG] Adding randomness field in dag node

consensus/src/consensusdb/consensusdb_test.rs

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use super::*;
-use crate::dag::{CertifiedNode, Node, Vote};
+use crate::dag::{CertifiedNode, Extensions, Node, Vote};
 use aptos_consensus_types::{
     block::block_test_utils::certificate_for_genesis,
     common::{Author, Payload},
@@ -93,7 +93,15 @@ fn test_dag() {
     let tmp_dir = TempPath::new();
     let db = ConsensusDB::new(&tmp_dir);
 
-    let node = Node::new(1, 1, Author::random(), 123, Payload::empty(false), vec![]);
+    let node = Node::new(
+        1,
+        1,
+        Author::random(),
+        123,
+        Payload::empty(false),
+        vec![],
+        Extensions::empty(),
+    );
     test_dag_type::<NodeSchema, <NodeSchema as Schema>::Key>(node.digest(), node.clone(), &db);
 
     let certified_node = CertifiedNode::new(node.clone(), AggregateSignature::empty());

consensus/src/dag/dag_driver.rs

@@ -5,7 +5,7 @@ use super::{
     dag_fetcher::FetchRequester,
     order_rule::OrderRule,
     storage::DAGStorage,
-    types::{CertifiedAck, DAGMessage},
+    types::{CertifiedAck, DAGMessage, Extensions},
     RpcHandler,
 };
 use crate::{
@@ -124,6 +124,7 @@ impl DagDriver {
             timestamp.as_micros() as u64,
             payload,
             strong_links,
+            Extensions::empty(),
         );
         self.storage
             .save_node(&new_node)

consensus/src/dag/mod.rs

@@ -17,4 +17,4 @@ mod tests;
 mod types;
 
 pub use dag_network::{RpcHandler, RpcWithFallback, TDAGNetworkSender};
-pub use types::{CertifiedNode, DAGMessage, DAGNetworkMessage, Node, NodeId, Vote};
+pub use types::{CertifiedNode, DAGMessage, DAGNetworkMessage, Extensions, Node, NodeId, Vote};

consensus/src/dag/tests/helpers.rs

@@ -1,6 +1,6 @@
 // Copyright © Aptos Foundation
 
-use crate::dag::types::{CertifiedNode, Node, NodeCertificate};
+use crate::dag::types::{CertifiedNode, Extensions, Node, NodeCertificate};
 use aptos_consensus_types::common::{Author, Payload, Round};
 use aptos_types::aggregate_signature::AggregateSignature;
 
@@ -9,7 +9,15 @@ pub(crate) fn new_certified_node(
     author: Author,
     parents: Vec<NodeCertificate>,
 ) -> CertifiedNode {
-    let node = Node::new(1, round, author, 0, Payload::empty(false), parents);
+    let node = Node::new(
+        1,
+        round,
+        author,
+        0,
+        Payload::empty(false),
+        parents,
+        Extensions::empty(),
+    );
     CertifiedNode::new(node, AggregateSignature::empty())
 }
 
@@ -19,5 +27,13 @@ pub(crate) fn new_node(
     author: Author,
     parents: Vec<NodeCertificate>,
 ) -> Node {
-    Node::new(0, round, author, timestamp, Payload::empty(false), parents)
+    Node::new(
+        0,
+        round,
+        author,
+        timestamp,
+        Payload::empty(false),
+        parents,
+        Extensions::empty(),
+    )
 }

consensus/src/dag/tests/types_test.rs

@@ -4,8 +4,8 @@ use super::helpers::new_node;
 use crate::dag::{
     tests::helpers::new_certified_node,
     types::{
-        CertifiedNode, DagSnapshotBitmask, Node, NodeCertificate, NodeMetadata, RemoteFetchRequest,
-        TDAGMessage,
+        CertifiedNode, DagSnapshotBitmask, Extensions, Node, NodeCertificate, NodeMetadata,
+        RemoteFetchRequest, TDAGMessage,
     },
 };
 use aptos_consensus_types::common::Payload;
@@ -24,6 +24,7 @@ fn test_node_verify() {
         NodeMetadata::new_for_test(0, 0, signers[0].author(), 0, HashValue::random()),
         Payload::empty(false),
         vec![],
+        Extensions::empty(),
     );
     assert_eq!(
         invalid_node
@@ -64,6 +65,7 @@ fn test_certified_node_verify() {
         NodeMetadata::new_for_test(0, 0, signers[0].author(), 0, HashValue::random()),
         Payload::empty(false),
         vec![],
+        Extensions::empty(),
     );
     let invalid_certified_node = CertifiedNode::new(invalid_node, AggregateSignature::empty());
     assert_eq!(

consensus/src/dag/types.rs

@@ -38,6 +38,18 @@ impl TDAGMessage for CertifiedAck {
     }
 }
 
+#[derive(Clone, Serialize, Deserialize, CryptoHasher, Debug, PartialEq)]
+pub enum Extensions {
+    Empty,
+    // Reserved for future extensions such as randomness shares
+}
+
+impl Extensions {
+    pub fn empty() -> Self {
+        Self::Empty
+    }
+}
+
 #[derive(Serialize)]
 struct NodeWithoutDigest<'a> {
     epoch: u64,
@@ -46,6 +58,7 @@ struct NodeWithoutDigest<'a> {
     timestamp: u64,
     payload: &'a Payload,
     parents: &'a Vec<NodeCertificate>,
+    extensions: &'a Extensions,
 }
 
 impl<'a> CryptoHash for NodeWithoutDigest<'a> {
@@ -68,6 +81,7 @@ impl<'a> From<&'a Node> for NodeWithoutDigest<'a> {
             timestamp: node.metadata.timestamp,
             payload: &node.payload,
             parents: &node.parents,
+            extensions: &node.extensions,
         }
     }
 }
@@ -131,6 +145,7 @@ pub struct Node {
     metadata: NodeMetadata,
     payload: Payload,
     parents: Vec<NodeCertificate>,
+    extensions: Extensions,
 }
 
 impl Node {
@@ -141,9 +156,17 @@ impl Node {
         timestamp: u64,
         payload: Payload,
         parents: Vec<NodeCertificate>,
+        extensions: Extensions,
     ) -> Self {
-        let digest =
-            Self::calculate_digest_internal(epoch, round, author, timestamp, &payload, &parents);
+        let digest = Self::calculate_digest_internal(
+            epoch,
+            round,
+            author,
+            timestamp,
+            &payload,
+            &parents,
+            &extensions,
+        );
 
         Self {
             metadata: NodeMetadata {
@@ -157,6 +180,7 @@ impl Node {
             },
             payload,
             parents,
+            extensions,
         }
     }
 
@@ -165,11 +189,13 @@ impl Node {
         metadata: NodeMetadata,
         payload: Payload,
         parents: Vec<NodeCertificate>,
+        extensions: Extensions,
     ) -> Self {
         Self {
             metadata,
             payload,
             parents,
+            extensions,
         }
     }
 
@@ -181,6 +207,7 @@ impl Node {
         timestamp: u64,
         payload: &Payload,
         parents: &Vec<NodeCertificate>,
+        extensions: &Extensions,
     ) -> HashValue {
         let node_with_out_digest = NodeWithoutDigest {
             epoch,
@@ -189,6 +216,7 @@ impl Node {
             timestamp,
             payload,
             parents,
+            extensions,
         };
         node_with_out_digest.hash()
     }
@@ -201,6 +229,7 @@ impl Node {
             self.metadata.timestamp,
             &self.payload,
             &self.parents,
+            &self.extensions,
         )
     }