Rename to id()

Author: howardwu

ledger/narwhal/batch-certificate/src/lib.rs

@@ -138,7 +138,7 @@ impl<N: Network> Hash for BatchCertificate<N> {
 
 impl<N: Network> BatchCertificate<N> {
     /// Returns the certificate ID.
-    pub const fn certificate_id(&self) -> Field<N> {
+    pub const fn id(&self) -> Field<N> {
         match self {
             Self::V1 { certificate_id, .. } => *certificate_id,
             Self::V2 { batch_header, .. } => batch_header.batch_id(),
@@ -279,7 +279,7 @@ pub mod test_helpers {
             sample_batch_certificate_for_round(previous_round, rng),
         ];
         // Construct the previous certificate IDs.
-        let previous_certificate_ids: IndexSet<_> = previous_certificates.iter().map(|c| c.certificate_id()).collect();
+        let previous_certificate_ids: IndexSet<_> = previous_certificates.iter().map(|c| c.id()).collect();
         // Sample the leader certificate.
         let certificate = sample_batch_certificate_for_round_with_previous_certificate_ids(
             current_round,

ledger/narwhal/subdag/src/lib.rs

@@ -57,14 +57,15 @@ fn sanity_check_subdag_with_dfs<N: Network>(subdag: &BTreeMap<u64, IndexSet<Batc
         commit.entry(certificate.round()).or_default().insert(certificate.clone());
         // Iterate over the previous certificate IDs.
         for previous_certificate_id in certificate.previous_certificate_ids() {
-            let Some(previous_certificate) = subdag.get(&(certificate.round() - 1)).and_then(|map| {
-                map.iter().find(|certificate| certificate.certificate_id() == *previous_certificate_id)
-            }) else {
+            let Some(previous_certificate) = subdag
+                .get(&(certificate.round() - 1))
+                .and_then(|map| map.iter().find(|certificate| certificate.id() == *previous_certificate_id))
+            else {
                 // It is either ordered or below the GC round.
                 continue;
             };
             // Insert the previous certificate into the set of already ordered certificates.
-            if !already_ordered.insert(previous_certificate.certificate_id()) {
+            if !already_ordered.insert(previous_certificate.id()) {
                 // If the previous certificate is already ordered, continue.
                 continue;
             }
@@ -108,7 +109,7 @@ impl<N: Network> Subdag<N> {
 
     /// Returns the certificate IDs of the subdag (from earliest round to latest round).
     pub fn certificate_ids(&self) -> impl Iterator<Item = Field<N>> + '_ {
-        self.values().flatten().map(BatchCertificate::certificate_id)
+        self.values().flatten().map(BatchCertificate::id)
     }
 
     /// Returns the leader certificate.
@@ -157,10 +158,7 @@ impl<N: Network> Subdag<N> {
         // Prepare the leaves.
         let leaves = cfg_iter!(self.subdag)
             .map(|(_, certificates)| {
-                certificates
-                    .iter()
-                    .flat_map(|certificate| certificate.certificate_id().to_bits_le())
-                    .collect::<Vec<_>>()
+                certificates.iter().flat_map(|certificate| certificate.id().to_bits_le()).collect::<Vec<_>>()
             })
             .collect::<Vec<_>>();
 
@@ -213,7 +211,7 @@ pub mod test_helpers {
         for _ in 0..AVAILABILITY_THRESHOLD {
             let certificate =
                 narwhal_batch_certificate::test_helpers::sample_batch_certificate_for_round(starting_round, rng);
-            previous_certificate_ids.insert(certificate.certificate_id());
+            previous_certificate_ids.insert(certificate.id());
             subdag.entry(starting_round).or_default().insert(certificate);
         }
 
@@ -222,7 +220,7 @@ pub mod test_helpers {
         for _ in 0..QUORUM_THRESHOLD {
             let certificate =
                 narwhal_batch_certificate::test_helpers::sample_batch_certificate_for_round_with_previous_certificate_ids(starting_round + 1, previous_certificate_ids.clone(), rng);
-            previous_certificate_ids_2.insert(certificate.certificate_id());
+            previous_certificate_ids_2.insert(certificate.id());
             subdag.entry(starting_round + 1).or_default().insert(certificate);
         }
 

ledger/store/src/block/mod.rs

@@ -405,10 +405,9 @@ pub trait BlockStorage<N: Network>: 'static + Clone + Send + Sync {
         // Retrieve the certificate IDs to store.
         let certificates_to_store = match block.authority() {
             Authority::Beacon(_) => Vec::new(),
-            Authority::Quorum(subdag) => subdag
-                .iter()
-                .flat_map(|(round, certificates)| certificates.iter().map(|c| (c.certificate_id(), *round)))
-                .collect(),
+            Authority::Quorum(subdag) => {
+                subdag.iter().flat_map(|(round, certificates)| certificates.iter().map(|c| (c.id(), *round))).collect()
+            }
         };
 
         // Prepare the rejected transaction IDs and their corresponding unconfirmed transaction IDs.
@@ -529,7 +528,7 @@ pub trait BlockStorage<N: Network>: 'static + Clone + Send + Sync {
             Some(authority) => match authority {
                 Cow::Owned(Authority::Beacon(_)) | Cow::Borrowed(Authority::Beacon(_)) => Vec::new(),
                 Cow::Owned(Authority::Quorum(ref subdag)) | Cow::Borrowed(Authority::Quorum(ref subdag)) => {
-                    subdag.values().flatten().map(|c| c.certificate_id()).collect()
+                    subdag.values().flatten().map(|c| c.id()).collect()
                 }
             },
             None => bail!("Failed to remove block: missing authority for block '{block_height}' ('{block_hash}')"),
@@ -798,7 +797,7 @@ pub trait BlockStorage<N: Network>: 'static + Clone + Send + Sync {
                 match subdag.get(&round) {
                     Some(certificates) => {
                         // Retrieve the certificate for the given certificate ID.
-                        match certificates.iter().find(|certificate| &certificate.certificate_id() == certificate_id) {
+                        match certificates.iter().find(|certificate| &certificate.id() == certificate_id) {
                             Some(certificate) => Ok(Some(certificate.clone())),
                             None => bail!("The certificate '{certificate_id}' is missing in block storage"),
                         }