lazy re-encode

Author: clabby

consensus/src/marshal/ingress/coding/mailbox.rs

@@ -107,7 +107,7 @@ where
     /// ## Panics
     ///
     /// Panics if the number of `participants` is not equal to the number of [Shard]s in the `block`
-    pub async fn broadcast_shards(&mut self, block: CodedBlock<B, S>, participants: Vec<P>) {
+    pub async fn broadcast_shards(&mut self, mut block: CodedBlock<B, S>, participants: Vec<P>) {
         assert_eq!(
             participants.len(),
             block.shards().len(),
@@ -277,7 +277,11 @@ where
             .set(start.elapsed().as_millis() as i64);
 
         // Attempt to decode the block from the encoded blob
-        let block = CodedBlock::<B, S>::decode_cfg(decoded.as_slice(), &self.block_codec_cfg)?;
+        let inner = B::read_cfg(&mut decoded.as_slice(), &self.block_codec_cfg)?;
+
+        // Construct a coding block with a _trusted_ commitment. `S::decode` verified the blob's
+        // integrity, so shards can be lazily re-constructed if need be.
+        let block = CodedBlock::new_trusted(inner, commitment);
 
         debug!(
             %commitment,

consensus/src/marshal/ingress/coding/types.rs

@@ -229,8 +229,10 @@ pub struct CodedBlock<B: Block, S: Scheme> {
     config: CodingConfig,
     /// The erasure coding commitment.
     commitment: S::Commitment,
-    /// The coded shards, along with corresponding coding proofs.
-    shards: Vec<S::Shard>,
+    /// The coded shards.
+    ///
+    /// These shards are optional to enable lazy construction.
+    shards: Option<Vec<S::Shard>>,
 }
 
 impl<B: Block<Commitment = CodingCommitment>, S: Scheme> CodedBlock<B, S> {
@@ -250,7 +252,17 @@ impl<B: Block<Commitment = CodingCommitment>, S: Scheme> CodedBlock<B, S> {
             inner,
             config,
             commitment,
-            shards,
+            shards: Some(shards),
+        }
+    }
+
+    /// Create a new [CodedBlock] from a [Block] and trusted [CodingCommitment].
+    pub fn new_trusted(inner: B, commitment: CodingCommitment) -> Self {
+        Self {
+            inner,
+            config: commitment.config(),
+            commitment: commitment.inner(),
+            shards: None,
         }
     }
 
@@ -260,16 +272,26 @@ impl<B: Block<Commitment = CodingCommitment>, S: Scheme> CodedBlock<B, S> {
     }
 
     /// Returns a refernce to the shards in this coded block.
-    pub fn shards(&self) -> &[S::Shard] {
-        &self.shards
+    pub fn shards(&mut self) -> &[S::Shard] {
+        match self.shards {
+            Some(ref shards) => shards,
+            None => {
+                let (commitment, shards) = Self::encode(&self.inner, self.config);
+
+                assert_eq!(commitment, self.commitment);
+
+                self.shards = Some(shards);
+                self.shards.as_ref().unwrap()
+            }
+        }
     }
 
     /// Returns a [Shard] at the given index, if the index is valid.
     pub fn shard<H: Hasher>(&self, index: usize) -> Option<Shard<S, H>> {
         Some(Shard::new(
             self.commitment(),
             index,
-            DistributionShard::Strong(self.shards.get(index)?.clone()),
+            DistributionShard::Strong(self.shards.as_ref()?.get(index)?.clone()),
         ))
     }
 
@@ -345,7 +367,7 @@ impl<B: Block, S: Scheme> Read for CodedBlock<B, S> {
             inner,
             config,
             commitment,
-            shards,
+            shards: Some(shards),
         })
     }
 }