fix(ledger/block): fix (de-)seralization of compact blocks

Author: kaimast

ledger/block/src/lib.rs

@@ -308,6 +308,32 @@ impl<N: Network> Block<N> {
         })
     }
 
+    /// Helper function to compute the solution transmission IDs.
+    pub fn compute_solution_transmission_ids(solutions: &Solutions<N>) -> Result<Vec<TransmissionID<N>>> {
+        match solutions.as_puzzle_solutions() {
+            Some(solutions) => {
+                let mut transmission_ids = Vec::with_capacity(solutions.solution_ids().count());
+                for (id, solution) in solutions.iter() {
+                    let checksum = Data::<Solution<N>>::Buffer(solution.to_bytes_le()?.into()).to_checksum::<N>()?;
+                    transmission_ids.push(TransmissionID::Solution(*id, checksum));
+                }
+                Ok(transmission_ids)
+            }
+            None => Ok(Vec::new()),
+        }
+    }
+
+    /// Helper function to compute the transaction transmission IDs.
+    pub fn compute_transaction_transmission_ids(transactions: &[Transaction<N>]) -> Result<Vec<TransmissionID<N>>> {
+        transactions
+            .iter()
+            .map(|tx| {
+                let checksum = Data::<Transaction<N>>::Buffer(tx.to_bytes_le()?.into()).to_checksum::<N>()?;
+                Ok(TransmissionID::Transaction(tx.id(), checksum))
+            })
+            .collect::<Result<Vec<_>>>()
+    }
+
     /// Borrow the Block and return a Subdag with full batch certificates.
     pub fn to_full_subdag(&self) -> Result<Subdag<N>> {
         let Block {
@@ -335,25 +361,9 @@ impl<N: Network> Block<N> {
             .map(|confirmed| confirmed.to_unconfirmed_transaction())
             .collect::<Result<Vec<_>>>()?;
         // Compute the transaction transmission IDs.
-        let transaction_transmission_ids = unconfirmed_transactions
-            .iter()
-            .map(|tx| {
-                let checksum = Data::<Transaction<N>>::Buffer(tx.to_bytes_le()?.into()).to_checksum::<N>()?;
-                Ok(TransmissionID::Transaction(tx.id(), checksum))
-            })
-            .collect::<Result<Vec<_>>>()?;
+        let transaction_transmission_ids = Self::compute_transaction_transmission_ids(&unconfirmed_transactions)?;
         // Compute the solution transmission IDs.
-        let solution_transmission_ids = match solutions.as_puzzle_solutions() {
-            Some(solutions) => {
-                let mut transmission_ids = Vec::with_capacity(solutions.solution_ids().count());
-                for (id, solution) in solutions.iter() {
-                    let checksum = Data::<Solution<N>>::Buffer(solution.to_bytes_le()?.into()).to_checksum::<N>()?;
-                    transmission_ids.push(TransmissionID::Solution(*id, checksum));
-                }
-                transmission_ids
-            }
-            None => Vec::new(),
-        };
+        let solution_transmission_ids = Self::compute_solution_transmission_ids(solutions)?;
 
         // Convert Quorum authority to subdag with full batch certificates.
         subdag.clone().into_full(

ledger/narwhal/subdag/src/lib.rs

@@ -280,11 +280,11 @@ impl<N: Network> Subdag<N> {
     /// Returns the subdag with full batch certificates.
     pub fn into_full(
         self,
-        solutions: &[TransmissionID<N>],
-        prior_solutions: &[TransmissionID<N>],
-        aborted_solutions: &[TransmissionID<N>],
+        solution_ids: &[TransmissionID<N>],
+        prior_solution_ids: &[TransmissionID<N>],
+        aborted_solution_ids: &[TransmissionID<N>],
         transaction_ids: &[TransmissionID<N>],
-        prior_transactions: &[TransmissionID<N>],
+        prior_transaction_ids: &[TransmissionID<N>],
         aborted_transaction_ids: &[TransmissionID<N>],
     ) -> Result<Subdag<N>> {
         let subdag = match self {
@@ -300,11 +300,11 @@ impl<N: Network> Subdag<N> {
             for certificate in compact_certificates.into_iter() {
                 // Convert compact certificate to batch certificate.
                 let batch_certificate = certificate.into_batch_certificate(
-                    solutions.iter(),
-                    prior_solutions.iter(),
-                    aborted_solutions.iter(),
+                    solution_ids.iter(),
+                    prior_solution_ids.iter(),
+                    aborted_solution_ids.iter(),
                     transaction_ids.iter(),
-                    prior_transactions.iter(),
+                    prior_transaction_ids.iter(),
                     aborted_transaction_ids.iter(),
                 )?;
                 batch_certificates.insert(batch_certificate);
@@ -397,7 +397,7 @@ impl<N: Network> Subdag<N> {
                 LeaderCertificate::Full(cert)
             }
             Self::Compact { subdag } => {
-                // Retrieve entry for the anchor round.
+                // Retrve entry for the anchor round.
                 let entry = subdag.iter().next_back();
                 debug_assert!(entry.is_some(), "There must be at least one round of certificates");
                 // Retrieve the certificates from the anchor round.

ledger/src/advance.rs

@@ -61,6 +61,9 @@ impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
             .construct_block_template(&previous_block, Some(&subdag), ratifications, solutions, transactions, rng)
             .with_context(|| "Failed to construct block template")?;
 
+        // Determine the version for this block.
+        let version = if N::CONSENSUS_VERSION(header.height()).unwrap() >= ConsensusVersion::V10 { 2 } else { 1 };
+
         // --- Solutions ---
         // Construct the solution transmission IDs.
         let solution_transmission_ids = solutions
@@ -95,7 +98,7 @@ impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
         );
         aborted_solution_transmission_ids.extend(early_aborted_solution_transmission_ids);
         // Construct the aborted solution IDs.
-        let aborted_solution_ids = if N::CONSENSUS_VERSION(self.latest_height()).unwrap() < ConsensusVersion::V10 {
+        let aborted_solution_ids = if version < 2 {
             Some(
                 aborted_solution_transmission_ids
                     .iter()
@@ -148,7 +151,7 @@ impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
         );
         aborted_transaction_transmission_ids.extend(early_aborted_transaction_transmission_ids);
         // Construct the aborted transaction IDs.
-        let aborted_transaction_ids = if N::CONSENSUS_VERSION(self.latest_height()).unwrap() < ConsensusVersion::V10 {
+        let aborted_transaction_ids = if version < 2 {
             Some(
                 aborted_transaction_transmission_ids
                     .iter()
@@ -163,7 +166,7 @@ impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
         };
 
         // Construct the compact Subdag
-        let subdag = if N::CONSENSUS_VERSION(self.latest_height()).unwrap() >= ConsensusVersion::V10 {
+        let subdag = if version >= 2 {
             subdag.into_compact(
                 solution_transmission_ids,
                 prior_solution_transmission_ids.clone(),
@@ -181,7 +184,7 @@ impl<N: Network, C: ConsensusStorage<N>> Ledger<N, C> {
             aborted_solution_transmission_ids,
             prior_transaction_transmission_ids,
             aborted_transaction_transmission_ids,
-        ) = if N::CONSENSUS_VERSION(self.latest_height()).unwrap() >= ConsensusVersion::V10 {
+        ) = if version >= 2 {
             (
                 Some(prior_solution_transmission_ids),
                 Some(aborted_solution_transmission_ids),