Cleanup up Deployment

Author: d0cd

ledger/block/src/transaction/deployment/bytes.rs

@@ -18,13 +18,12 @@ use super::*;
 impl<N: Network> FromBytes for Deployment<N> {
     /// Reads the deployment from a buffer.
     fn read_le<R: Read>(mut reader: R) -> IoResult<Self> {
-        // Read the version.
-        let version = u8::read_le(&mut reader)?;
-        // Ensure the version is valid.
-        match version {
-            1 | 2 => {} // Do nothing.
-            0 | 3..=u8::MAX => return Err(error("Invalid deployment version")),
-        }
+        // Read the version and ensure the version is valid.
+        let version = match u8::read_le(&mut reader)? {
+            1 => DeploymentVersion::V1,
+            2 => DeploymentVersion::V2,
+            version => return Err(error(format!("Invalid deployment version: {}", version))),
+        };
 
         // Read the edition.
         let edition = u16::read_le(&mut reader)?;
@@ -46,10 +45,10 @@ impl<N: Network> FromBytes for Deployment<N> {
             verifying_keys.push((identifier, (verifying_key, certificate)));
         }
 
-        // If the version is 2, read the program checksum.
+        // If the deployment version is 2, read the program checksum.
         let program_checksum = match version {
-            0 | 1 | 3..=u8::MAX => None,
-            2 => Some(Field::<N>::read_le(&mut reader)?),
+            DeploymentVersion::V1 => None,
+            DeploymentVersion::V2 => Some(Field::<N>::read_le(&mut reader)?),
         };
 
         // Return the deployment.
@@ -61,10 +60,7 @@ impl<N: Network> ToBytes for Deployment<N> {
     /// Writes the deployment to a buffer.
     fn write_le<W: Write>(&self, mut writer: W) -> IoResult<()> {
         // Write the version.
-        match self.program_checksum.is_some() {
-            false => 1u8.write_le(&mut writer)?,
-            true => 2u8.write_le(&mut writer)?,
-        };
+        (self.version() as u8).write_le(&mut writer)?;
         // Write the edition.
         self.edition.write_le(&mut writer)?;
         // Write the program.
@@ -96,12 +92,20 @@ mod tests {
     fn test_bytes() -> Result<()> {
         let rng = &mut TestRng::default();
 
-        // Construct a new deployment.
-        let expected = test_helpers::sample_deployment(rng);
+        // Construct the deployments.
+        for expected in [test_helpers::sample_deployment(rng), test_helpers::sample_deployment_with_checksum(rng)] {
+            // Check the byte representation.
+            let expected_bytes = expected.to_bytes_le()?;
+            assert_eq!(expected, Deployment::read_le(&expected_bytes[..])?);
+
+            // Construct a new deployment with a checksum.
+            let expected = test_helpers::sample_deployment_with_checksum(rng);
+
+            // Check the byte representation.
+            let expected_bytes = expected.to_bytes_le()?;
+            assert_eq!(expected, Deployment::read_le(&expected_bytes[..])?);
+        }
 
-        // Check the byte representation.
-        let expected_bytes = expected.to_bytes_le()?;
-        assert_eq!(expected, Deployment::read_le(&expected_bytes[..])?);
         Ok(())
     }
 }

ledger/block/src/transaction/deployment/mod.rs

@@ -37,8 +37,7 @@ pub struct Deployment<N: Network> {
     /// The mapping of function names to their verifying key and certificate.
     verifying_keys: Vec<(Identifier<N>, (VerifyingKey<N>, Certificate<N>))>,
     /// An optional checksum for the program.
-    /// This purpose of this field is to create an implicit versioning mechanism for deployments.
-    /// Existing deployments do not have a checksum, while new deployments will have a checksum.
+    /// This purpose of this field is to create an implicit, backwards-compatible versioning mechanism for deployments.
     /// Before a given migration height, the checksum will **not** be allowed.
     /// After the migration height, the checksum will be required.
     program_checksum: Option<Field<N>>,
@@ -178,6 +177,25 @@ impl<N: Network> Deployment<N> {
     pub fn to_deployment_id(&self) -> Result<Field<N>> {
         Ok(*Transaction::deployment_tree(self)?.root())
     }
+
+    /// Sets the program checksum.
+    pub fn set_program_checksum(&mut self, program_checksum: Option<Field<N>>) {
+        self.program_checksum = program_checksum;
+    }
+
+    // An internal function to return the implicit deployment version.
+    fn version(&self) -> DeploymentVersion {
+        match self.program_checksum {
+            None => DeploymentVersion::V1,
+            Some(_) => DeploymentVersion::V2,
+        }
+    }
+}
+
+// An internal enum to represent the deployment version.
+enum DeploymentVersion {
+    V1 = 1,
+    V2 = 2,
 }
 
 #[cfg(test)]
@@ -222,4 +240,15 @@ function compute:
             })
             .clone()
     }
+
+    pub(crate) fn sample_deployment_with_checksum(rng: &mut TestRng) -> Deployment<CurrentNetwork> {
+        // Get the deployment.
+        let mut deployment = sample_deployment(rng);
+        // Add a checksum.
+        let program_checksum = deployment.program.checksum().unwrap();
+        // Set the checksum.
+        deployment.set_program_checksum(Some(program_checksum));
+        // Return the deployment.
+        deployment
+    }
 }

ledger/block/src/transaction/deployment/serialize.rs

@@ -20,7 +20,10 @@ impl<N: Network> Serialize for Deployment<N> {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         match serializer.is_human_readable() {
             true => {
-                let len = if self.program_checksum.is_some() { 4 } else { 3 };
+                let len = match self.version() {
+                    DeploymentVersion::V1 => 3,
+                    DeploymentVersion::V2 => 4,
+                };
                 let mut deployment = serializer.serialize_struct("Deployment", len)?;
                 deployment.serialize_field("edition", &self.edition)?;
                 deployment.serialize_field("program", &self.program)?;
@@ -71,17 +74,17 @@ mod tests {
     fn test_serde_json() -> Result<()> {
         let rng = &mut TestRng::default();
 
-        // Sample the deployment.
-        let expected = test_helpers::sample_deployment(rng);
+        // Sample the deployments.
+        for expected in [test_helpers::sample_deployment(rng), test_helpers::sample_deployment_with_checksum(rng)] {
+            // Serialize
+            let expected_string = &expected.to_string();
+            let candidate_string = serde_json::to_string(&expected)?;
+            assert_eq!(expected, serde_json::from_str(&candidate_string)?);
 
-        // Serialize
-        let expected_string = &expected.to_string();
-        let candidate_string = serde_json::to_string(&expected)?;
-        assert_eq!(expected, serde_json::from_str(&candidate_string)?);
-
-        // Deserialize
-        assert_eq!(expected, Deployment::from_str(expected_string)?);
-        assert_eq!(expected, serde_json::from_str(&candidate_string)?);
+            // Deserialize
+            assert_eq!(expected, Deployment::from_str(expected_string)?);
+            assert_eq!(expected, serde_json::from_str(&candidate_string)?);
+        }
 
         Ok(())
     }
@@ -90,17 +93,17 @@ mod tests {
     fn test_bincode() -> Result<()> {
         let rng = &mut TestRng::default();
 
-        // Sample the deployment.
-        let expected = test_helpers::sample_deployment(rng);
+        // Sample the deployments
+        for expected in [test_helpers::sample_deployment(rng), test_helpers::sample_deployment_with_checksum(rng)] {
+            // Serialize
+            let expected_bytes = expected.to_bytes_le()?;
+            let expected_bytes_with_size_encoding = bincode::serialize(&expected)?;
+            assert_eq!(&expected_bytes[..], &expected_bytes_with_size_encoding[8..]);
 
-        // Serialize
-        let expected_bytes = expected.to_bytes_le()?;
-        let expected_bytes_with_size_encoding = bincode::serialize(&expected)?;
-        assert_eq!(&expected_bytes[..], &expected_bytes_with_size_encoding[8..]);
-
-        // Deserialize
-        assert_eq!(expected, Deployment::read_le(&expected_bytes[..])?);
-        assert_eq!(expected, bincode::deserialize(&expected_bytes_with_size_encoding[..])?);
+            // Deserialize
+            assert_eq!(expected, Deployment::read_le(&expected_bytes[..])?);
+            assert_eq!(expected, bincode::deserialize(&expected_bytes_with_size_encoding[..])?);
+        }
 
         Ok(())
     }