fix(cardano-blockchain-types): handle unset data

Signed-off-by: bkioshn <[email protected]>

Author: bkioshn

rust/cardano-blockchain-types/src/metadata/cip36/key_registration.rs

@@ -30,26 +30,33 @@ use super::voting_pk::VotingPubKey;
 #[derive(Clone, Default, Debug)]
 pub(crate) struct Cip36KeyRegistration {
     /// Is this CIP36 or CIP15 format.
+    /// None if not either CIP36 or CIP15.
     pub is_cip36: Option<bool>,
     /// Voting public keys (called Delegations in the CIP-36 Spec).
     /// Field 1 in the CIP-36 61284 Spec.
     pub voting_pks: Vec<VotingPubKey>,
     /// Stake public key to associate with the voting keys.
     /// Field 2 in the CIP-36 61284 Spec.
-    pub stake_pk: VerifyingKey,
+    /// None if it is not set.
+    pub stake_pk: Option<VerifyingKey>,
     /// Payment Address to associate with the voting keys.
     /// Field 3 in the CIP-36 61284 Spec.
+    /// None if it is not set.
     pub payment_addr: Option<ShelleyAddress>,
     /// Nonce (nonce that has been slot corrected).
     /// Field 4 in the CIP-36 61284 Spec.
-    pub nonce: u64,
+    /// None if it is not set.
+    pub nonce: Option<u64>,
     /// Registration Purpose (Always 0 for Catalyst).
     /// Field 5 in the CIP-36 61284 Spec.
-    pub purpose: u64,
+    /// None if it is not set.
+    pub purpose: Option<u64>,
     /// Raw nonce (nonce that has not had slot correction applied).
-    pub raw_nonce: u64,
+    /// None if it is not set.
+    pub raw_nonce: Option<u64>,
     /// Is payment address payable? (not a script)
-    pub is_payable: bool,
+    /// None if it is not set.
+    pub is_payable: Option<bool>,
 }
 
 /// Enum of CIP36 registration (61284) with its associated unsigned integer key.
@@ -74,9 +81,6 @@ impl Decode<'_, ()> for Cip36KeyRegistration {
 
         let mut cip36_key_registration = Cip36KeyRegistration::default();
 
-        // Record of founded keys. Check for duplicate keys in the map
-        let mut found_keys: Vec<Cip36KeyRegistrationKeys> = Vec::new();
-
         // Record of errors found during decoding
         let mut err_report = Vec::new();
 
@@ -86,11 +90,11 @@ impl Decode<'_, ()> for Cip36KeyRegistration {
             if let Some(key) = Cip36KeyRegistrationKeys::from_repr(key) {
                 match key {
                     Cip36KeyRegistrationKeys::VotingKey => {
-                        if found_keys.contains(&key) {
+                        if !cip36_key_registration.voting_pks.is_empty() {
                             err_report.push(format!(
                                 "Duplicate key in CIP36 Key Registration voting key at item {} in map", index + 1),
                             );
-                            continue;
+                            continue;    
                         }
                         if let Some((is_cip36, voting_keys)) = decode_voting_key(d, &mut err_report)
                         {
@@ -99,77 +103,67 @@ impl Decode<'_, ()> for Cip36KeyRegistration {
                         }
                     },
                     Cip36KeyRegistrationKeys::StakePk => {
-                        if found_keys.contains(&key) {
+                        if cip36_key_registration.stake_pk.is_some() {
                             err_report.push(format!(
                                 "Duplicate key in CIP36 Key Registration stake public key at item {} in map", index + 1),
                             );
                             continue;
                         }
                         if let Some(stake_pk) = decode_stake_pk(d, &mut err_report) {
-                            cip36_key_registration.stake_pk = stake_pk;
+                            cip36_key_registration.stake_pk = Some(stake_pk);
                         }
                     },
                     Cip36KeyRegistrationKeys::PaymentAddr => {
-                        if found_keys.contains(&key) {
+                        if cip36_key_registration.payment_addr.is_some() {
                             err_report.push(format!(
                                 "Duplicate key in CIP36 Key Registration payment address at item {} in map", index + 1),
                             );
                             continue;
                         }
                         if let Some(shelley_addr) = decode_payment_addr(d, &mut err_report) {
                             cip36_key_registration.payment_addr = Some(shelley_addr.clone());
-                            cip36_key_registration.is_payable = !shelley_addr.payment().is_script();
+                            cip36_key_registration.is_payable = Some(!shelley_addr.payment().is_script());
                         }
                     },
                     Cip36KeyRegistrationKeys::Nonce => {
-                        if found_keys.contains(&key) {
+                        if cip36_key_registration.raw_nonce.is_some() {
                             err_report.push(format!(
-                                "Duplicate key in CIP36 Key Registration nonce at item {} in map",
-                                index + 1
-                            ));
+                                "Duplicate key in CIP36 Key Registration nonce at item {} in map", index + 1),
+                            );
                             continue;
                         }
                         if let Some(nonce) = decode_nonce(d, &mut err_report) {
-                            cip36_key_registration.nonce = nonce;
+                            cip36_key_registration.raw_nonce = Some(nonce);
                         }
                     },
                     Cip36KeyRegistrationKeys::Purpose => {
-                        if found_keys.contains(&key) {
+                        if cip36_key_registration.purpose.is_some() {
                             err_report.push(format!(
-                                "Duplicate key in CIP36 Key Registration purpose at item {} in map",
-                                index + 1
-                            ));
+                                "Duplicate key in CIP36 Key Registration purpose at item {} in map", index + 1),
+                            );
                             continue;
                         }
                         if let Some(purpose) = decode_purpose(d, &mut err_report) {
-                            cip36_key_registration.purpose = purpose;
+                            cip36_key_registration.purpose = Some(purpose);
                         }
                     },
                 }
-
-                // Update the founded keys.
-                found_keys.push(key);
             }
         }
 
-        if !found_keys.contains(&Cip36KeyRegistrationKeys::VotingKey) {
-            err_report
-                .push("Missing required key in CIP36 Key Registration: Voting Key".to_string());
+        if cip36_key_registration.voting_pks.is_empty() {
+            err_report.push("Missing required key in CIP36 Key Registration: Voting Key".to_string());
         }
 
-        if !found_keys.contains(&Cip36KeyRegistrationKeys::StakePk) {
-            err_report.push(
-                "Missing required key in CIP36 Key Registration: Stake Public Key".to_string(),
-            );
+        if cip36_key_registration.stake_pk.is_none() {
+            err_report.push("Missing required key in CIP36 Key Registration: Stake Public Key".to_string());
         }
 
-        if !found_keys.contains(&Cip36KeyRegistrationKeys::PaymentAddr) {
-            err_report.push(
-                "Missing required key in CIP36 Key Registration: Payment Address".to_string(),
-            );
+        if cip36_key_registration.payment_addr.is_none() {
+            err_report.push("Missing required key in CIP36 Key Registration: Payment Address".to_string());
         }
 
-        if !found_keys.contains(&Cip36KeyRegistrationKeys::Nonce) {
+        if cip36_key_registration.raw_nonce.is_none() {
             err_report.push("Missing required key in CIP36 Key Registration: Nonce".to_string());
         }
 
@@ -459,4 +453,14 @@ mod tests {
         assert!(!is_cip36.unwrap());
         assert_eq!(voting_pk.len(), 1);
     }
+
+    #[test]
+    fn test_decode_nonce() {
+        let hex_data = hex::decode("1A014905D1").expect("cannot decode hex");
+        let mut decoder = Decoder::new(&hex_data);
+        let mut err_report = Vec::new();
+        let nonce = decode_nonce(&mut decoder, &mut err_report);
+        assert!(err_report.is_empty());
+        assert_eq!(nonce.unwrap(), 21562833);
+    }
 }

rust/cardano-blockchain-types/src/metadata/cip36/mod.rs

@@ -75,8 +75,8 @@ impl Cip36 {
 
         let key_registration = match Cip36KeyRegistration::decode(&mut key_registration, &mut ()) {
             Ok(mut metadata) => {
-                let nonce = if is_catalyst_strict && metadata.raw_nonce > slot {
-                    slot
+                let nonce = if is_catalyst_strict && metadata.raw_nonce > Some(slot) {
+                    Some(slot)
                 } else {
                     metadata.raw_nonce
                 };
@@ -133,8 +133,8 @@ impl Cip36 {
 
     /// Get the stake public key from the registration.
     #[must_use]
-    pub fn stake_pk(&self) -> VerifyingKey {
-        self.key_registration.stake_pk
+    pub fn stake_pk(&self) -> Option<&VerifyingKey> {
+        self.key_registration.stake_pk.as_ref()
     }
 
     /// Get the payment address from the registration.
@@ -145,25 +145,25 @@ impl Cip36 {
 
     /// Get the nonce from the registration.
     #[must_use]
-    pub fn nonce(&self) -> u64 {
+    pub fn nonce(&self) -> Option<u64> {
         self.key_registration.nonce
     }
 
     /// Get the purpose from the registration.
     #[must_use]
-    pub fn purpose(&self) -> u64 {
+    pub fn purpose(&self) -> Option<u64> {
         self.key_registration.purpose
     }
 
     /// Get the raw nonce from the registration.
     #[must_use]
-    pub fn raw_nonce(&self) -> u64 {
+    pub fn raw_nonce(&self) -> Option<u64> {
         self.key_registration.raw_nonce
     }
 
     /// Is the payment address in the registration payable?
     #[must_use]
-    pub fn is_payable(&self) -> bool {
+    pub fn is_payable(&self) -> Option<bool> {
         self.key_registration.is_payable
     }
 

rust/cardano-blockchain-types/src/metadata/cip36/validation.rs

@@ -29,11 +29,16 @@ pub(crate) fn validate_signature(
         return false;
     };
 
-    if let Ok(()) = cip36.stake_pk().verify_strict(hash.as_bytes(), &sig) {
-        true
+    if let Some(stake_pk) = cip36.stake_pk() {
+        if let Ok(()) = stake_pk.verify_strict(hash.as_bytes(), &sig) {
+            return true;
+        } else {
+            validation_report.push("Validate CIP36 Signature, cannot verify signature".to_string());
+            return false;
+        }
     } else {
-        validation_report.push("Validate CIP36 Signature, cannot verify signature".to_string());
-        false
+        validation_report.push("Validate CIP36 Signature, stake public key is missing".to_string());
+        return false;
     }
 }
 
@@ -73,14 +78,19 @@ pub(crate) fn validate_voting_keys(cip36: &Cip36, validation_report: &mut Vec<St
 
 /// Validate the purpose.
 pub(crate) fn validate_purpose(cip36: &Cip36, validation_report: &mut Vec<String>) -> bool {
-    if cip36.is_strict_catalyst() && cip36.purpose() != PROJECT_CATALYST_PURPOSE {
-        validation_report.push(format!(
-            "Validate CIP-36 Purpose, registration contains unknown purpose: {}",
-            cip36.purpose()
-        ));
-        return false;
+    if let Some(purpose) = cip36.purpose() {
+        if cip36.is_strict_catalyst() && purpose != PROJECT_CATALYST_PURPOSE {
+            validation_report.push(format!(
+                "Validate CIP-36 Purpose, registration contains unknown purpose: {purpose}"
+            ));
+            return false;
+        }
+        true
+    } else {
+        validation_report
+            .push("Validate CIP-36 Purpose, registration purpose is missing".to_string());
+        false
     }
-    true
 }
 
 #[cfg(test)]
@@ -186,20 +196,21 @@ mod tests {
 
     #[test]
     fn test_validate_purpose() {
-        let cip36 = create_empty_cip36(true);
+        let mut cip36 = create_empty_cip36(true);
+        cip36.key_registration.purpose = Some(0);
         let mut report = Vec::new();
 
         let valid = validate_purpose(&cip36, &mut report);
 
         assert_eq!(report.len(), 0);
-        assert_eq!(cip36.purpose(), 0);
+        assert_eq!(cip36.purpose(), Some(0));
         assert!(valid);
     }
 
     #[test]
     fn test_validate_invalid_purpose() {
         let mut cip36 = create_empty_cip36(true);
-        cip36.key_registration.purpose = 1;
+        cip36.key_registration.purpose = Some(1);
         let mut report = Vec::new();
 
         let valid = validate_purpose(&cip36, &mut report);
@@ -209,7 +220,7 @@ mod tests {
             .first()
             .expect("Failed to get the first index")
             .contains("unknown purpose"));
-        assert_eq!(cip36.purpose(), 1);
+        assert_eq!(cip36.purpose(), Some(1));
         assert!(!valid);
     }
 }