shred from_payload

Author: behzadnouri

ledger/src/shred.rs

@@ -50,8 +50,12 @@
 //! payload can fit into one coding shred / packet.
 
 pub(crate) use shred_data::ShredData;
+pub use {
+    self::stats::{ProcessShredsStats, ShredFetchStats},
+    crate::shredder::Shredder,
+};
 use {
-    self::shred_code::ShredCode,
+    self::{shred_code::ShredCode, traits::Shred as _},
     crate::blockstore::MAX_DATA_SHREDS_PER_SLOT,
     bitflags::bitflags,
     num_enum::{IntoPrimitive, TryFromPrimitive},
@@ -69,10 +73,6 @@ use {
     std::fmt::Debug,
     thiserror::Error,
 };
-pub use {
-    self::stats::{ProcessShredsStats, ShredFetchStats},
-    crate::shredder::Shredder,
-};
 
 mod common;
 mod legacy;
@@ -335,9 +335,23 @@ impl Shred {
     }
 
     pub fn new_from_serialized_shred(shred: Vec<u8>) -> Result<Self, Error> {
-        Ok(match Self::shred_type_from_payload(&shred)? {
-            ShredType::Code => Self::from(ShredCode::from_payload(shred)?),
-            ShredType::Data => Self::from(ShredData::from_payload(shred)?),
+        Ok(match Shred::shred_variant_from_payload(&shred)? {
+            ShredVariant::LegacyCode => {
+                let shred = legacy::ShredCode::from_payload(shred)?;
+                Self::from(ShredCode::from(shred))
+            }
+            ShredVariant::LegacyData => {
+                let shred = legacy::ShredData::from_payload(shred)?;
+                Self::from(ShredData::from(shred))
+            }
+            ShredVariant::MerkleCode(_) => {
+                let shred = merkle::ShredCode::from_payload(shred)?;
+                Self::from(ShredCode::from(shred))
+            }
+            ShredVariant::MerkleData(_) => {
+                let shred = merkle::ShredData::from_payload(shred)?;
+                Self::from(ShredData::from(shred))
+            }
         })
     }
 

ledger/src/shred/merkle.rs

@@ -113,6 +113,7 @@ impl Shred for ShredData {
         if payload.len() < Self::SIZE_OF_PAYLOAD {
             return Err(Error::InvalidPayloadSize(payload.len()));
         }
+        payload.truncate(Self::SIZE_OF_PAYLOAD);
         let mut cursor = Cursor::new(&payload[..]);
         let common_header: ShredCommonHeader = deserialize_from_with_limit(&mut cursor)?;
         let proof_size = match common_header.shred_variant {
@@ -130,7 +131,6 @@ impl Shred for ShredData {
             .take(usize::from(proof_size))
             .collect::<Result<_, _>>()?;
         let merkle_branch = MerkleBranch { root, proof };
-        payload.truncate(Self::SIZE_OF_PAYLOAD);
         let shred = Self {
             common_header,
             data_header,
@@ -157,8 +157,6 @@ impl Shred for ShredData {
     }
 
     fn erasure_shard_as_slice(&self) -> Result<&[u8], Error> {
-        // TODO: relax this check
-        // TODO: add this to sanitize
         if self.payload.len() != Self::SIZE_OF_PAYLOAD {
             return Err(Error::InvalidPayloadSize(self.payload.len()));
         }

ledger/src/shred/shred_code.rs

@@ -59,11 +59,6 @@ impl ShredCode {
         ))
     }
 
-    pub(super) fn from_payload(shred: Vec<u8>) -> Result<Self, Error> {
-        // TODO: need to inspect variant byte
-        Ok(Self::from(legacy::ShredCode::from_payload(shred)?))
-    }
-
     pub(super) fn num_data_shreds(&self) -> u16 {
         self.coding_header().num_data_shreds
     }

ledger/src/shred/shred_data.rs

@@ -57,11 +57,6 @@ impl ShredData {
         ))
     }
 
-    pub(super) fn from_payload(shred: Vec<u8>) -> Result<Self, Error> {
-        // TODO: need to inspect variant byte
-        Ok(Self::from(legacy::ShredData::from_payload(shred)?))
-    }
-
     pub(super) fn last_in_slot(&self) -> bool {
         let flags = self.data_header().flags;
         flags.contains(ShredFlags::LAST_SHRED_IN_SLOT)
@@ -122,9 +117,7 @@ pub(super) fn erasure_shard_index<T: ShredDataTrait>(shred: &T) -> Option<usize>
     usize::try_from(index).ok()
 }
 
-// TODO: do i need to verify shred-variant here?
 pub(super) fn sanitize<T: ShredDataTrait>(shred: &T) -> Result<(), Error> {
-    // TODO: This is unnecessary.
     let common_header = shred.common_header();
     let data_header = shred.data_header();
     if shred.erasure_shard_index().is_none() {