Pass a problem report to Decode::decode as a context (#789)

Author: stanislav-tkach

rust/catalyst-contest/src/contest_ballot/ballot.rs

@@ -39,9 +39,9 @@ impl ContestBallot {
             "Document must be Contest Ballot type"
         );
 
-        let report = ProblemReport::new("Contest Ballot");
+        let mut report = ProblemReport::new("Contest Ballot");
 
-        let payload = payload(doc, &report);
+        let payload = payload(doc, &mut report);
         if let Some(payload) = &payload {
             check_proof(payload, &report);
         }
@@ -66,7 +66,7 @@ impl ContestBallot {
 /// Returns a decoded contest ballot payload.
 pub fn payload(
     doc: &CatalystSignedDocument,
-    report: &ProblemReport,
+    report: &mut ProblemReport,
 ) -> Option<ContentBallotPayload> {
     let Ok(bytes) = doc.decoded_content() else {
         report.functional_validation(
@@ -77,9 +77,7 @@ pub fn payload(
     };
 
     let mut decoder = minicbor::Decoder::new(&bytes);
-    // TODO: Pass a problem report in the decode context. See the issue for more details:
-    // https://github.com/input-output-hk/catalyst-libs/issues/775
-    let Ok(payload) = ContentBallotPayload::decode(&mut decoder, &mut ()) else {
+    let Ok(payload) = ContentBallotPayload::decode(&mut decoder, report) else {
         report.functional_validation(
             "Invalid document content: unable to decode CBOR",
             "Cannot get a document content during Contest Ballot document validation.",

rust/catalyst-contest/src/contest_ballot/payload.rs

@@ -2,6 +2,7 @@
 
 use std::collections::BTreeMap;
 
+use catalyst_signed_doc::problem_report::ProblemReport;
 use cbork_utils::{decode_context::DecodeCtx, map::Map};
 use minicbor::{Decode, Decoder, Encode, Encoder, encode::Write};
 
@@ -34,13 +35,15 @@ pub struct ContentBallotPayload {
     pub voter_choices: Option<EncryptedChoices>,
 }
 
-impl Decode<'_, ()> for ContentBallotPayload {
+impl Decode<'_, ProblemReport> for ContentBallotPayload {
     fn decode(
         d: &mut Decoder<'_>,
-        ctx: &mut (),
+        report: &mut ProblemReport,
     ) -> Result<Self, minicbor::decode::Error> {
         use minicbor::data::Type;
 
+        let context = "Content ballot payload decoding";
+
         let map = Map::decode(d, &mut DecodeCtx::Deterministic)?;
 
         let mut choices = BTreeMap::new();
@@ -55,36 +58,56 @@ impl Decode<'_, ()> for ContentBallotPayload {
             match key_decoder.datatype()? {
                 Type::U8 | Type::U16 | Type::U32 | Type::U64 => {
                     let key = key_decoder.u64()?;
-                    let val = Choices::decode(&mut value_decoder, ctx)?;
-                    choices.insert(key, val);
+                    match Choices::decode(&mut value_decoder, &mut ()) {
+                        Ok(val) => {
+                            choices.insert(key, val);
+                        },
+                        Err(e) => {
+                            report.other(
+                                &format!("Unable to decode choices for {key} key: {e:?}"),
+                                context,
+                            );
+                        },
+                    }
                 },
                 Type::String => {
                     match key_decoder.str()? {
                         "column-proof" => {
-                            return Err(minicbor::decode::Error::message(
+                            report.other(
                                 "column-proof is a placeholder and shouldn't be used",
-                            ));
+                                context,
+                            );
                         },
                         "matrix-proof" => {
-                            return Err(minicbor::decode::Error::message(
+                            report.other(
                                 "matrix-proof is a placeholder and shouldn't be used",
-                            ));
+                                context,
+                            );
                         },
                         "voter-choices" => {
-                            voter_choices =
-                                Some(EncryptedChoices::decode(&mut value_decoder, ctx)?);
+                            match EncryptedChoices::decode(&mut value_decoder, &mut ()) {
+                                Ok(v) => voter_choices = Some(v),
+                                Err(e) => {
+                                    report.other(
+                                        &format!("Unable to decode encrypted choices: {e:?}"),
+                                        context,
+                                    );
+                                },
+                            }
                         },
                         key => {
-                            return Err(minicbor::decode::Error::message(format!(
-                                "Unexpected content ballot payload key value: {key:?}"
-                            )));
+                            report.other(
+                                &format!("Unexpected content ballot payload key value: {key:?}"),
+                                context,
+                            );
                         },
                     }
                 },
                 t => {
-                    return Err(minicbor::decode::Error::message(format!(
-                        "Unexpected content ballot payload key type: {t:?}"
-                    )));
+                    report.other(
+                        &format!("Unexpected content ballot payload key type: {t:?}"),
+                        context,
+                    );
                 },
             }
         }
@@ -160,7 +183,10 @@ mod tests {
         original
             .encode(&mut Encoder::new(&mut buffer), &mut ())
             .unwrap();
-        let decoded = ContentBallotPayload::decode(&mut Decoder::new(&buffer), &mut ()).unwrap();
+        let mut report = ProblemReport::new("test");
+        let decoded =
+            ContentBallotPayload::decode(&mut Decoder::new(&buffer), &mut report).unwrap();
         assert_eq!(original, decoded);
+        assert!(!report.is_problematic());
     }
 }

rust/catalyst-contest/src/contest_ballot/rule.rs

@@ -16,7 +16,8 @@ impl CatalystSignedDocumentValidationRule for ContestBallotRule {
         doc: &CatalystSignedDocument,
         provider: &dyn Provider,
     ) -> anyhow::Result<bool> {
-        let payload = payload(doc, doc.report());
+        let mut report = doc.report().clone();
+        let payload = payload(doc, &mut report);
         if let Some(payload) = &payload {
             check_proof(payload, doc.report());
         }