feat(rust/signed-doc): Apply deterministic array decoding to Collaborators and DocumentRefs (#665)

* feat: initial

* chore: set back version

* test: collaborators

* fix: cspell

* fix: cspell

* fix: cspell

---------

Co-authored-by: Alex Pozhylenkov <[email protected]>

Author: apskhem

rust/signed_doc/Cargo.toml

@@ -12,7 +12,7 @@ workspace = true
 
 [dependencies]
 catalyst-types = { version = "0.0.11", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "catalyst-types/v0.0.11" }
-cbork-utils = { version = "0.0.2", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "cbork-utils-v0.0.2" }
+cbork-utils = { version = "0.0.3", git = "https://github.com/input-output-hk/catalyst-libs.git", tag = "cbork-utils/v0.0.3" }
 
 # When updating the specification version, it should also be updated for the `catalyst-signed-doc-macro` crate.
 catalyst-signed-doc-macro = { version = "0.0.1", path = "../catalyst-signed-doc-macro" }

rust/signed_doc/src/metadata/collaborators.rs

@@ -47,7 +47,7 @@ impl minicbor::Decode<'_, ()> for Collaborators {
         d: &mut minicbor::Decoder<'_>,
         _ctx: &mut (),
     ) -> Result<Self, minicbor::decode::Error> {
-        Array::decode(d, &mut DecodeCtx::Deterministic)
+        Array::decode(d, &mut DecodeCtx::ArrayDeterministic)
             .and_then(|arr| {
                 if arr.is_empty() {
                     Err(minicbor::decode::Error::message(
@@ -117,7 +117,7 @@ impl serde::Serialize for Collaborators {
 
 #[cfg(test)]
 mod tests {
-    use minicbor::{Decode, Decoder, Encoder};
+    use minicbor::{Decode, Decoder, Encode, Encoder};
     use test_case::test_case;
 
     use super::*;
@@ -152,4 +152,46 @@ mod tests {
             Collaborators::decode(&mut Decoder::new(e.into_writer().as_slice()), &mut ()).is_err()
         );
     }
+
+    #[test]
+    fn test_deterministic_decoding() {
+        /* cspell:disable */
+        let mut cat_ids = vec![
+            CatalystId::from_str(
+                "id.catalyst://preprod.cardano/FftxFnOrj2qmTuB2oZG2v0YEWJfKvQ9Gg8AgNAhDsKE/7/3",
+            )
+            .unwrap(),
+            CatalystId::from_str(
+                "id.catalyst://midnight/FftxFnOrj2qmTuB2oZG2v0YEWJfKvQ9Gg8AgNAhDsKE/0/1",
+            )
+            .unwrap(),
+        ];
+        /* cspell:enable */
+        cat_ids.sort_by(|a, b| {
+            let a = a.to_string();
+            let b = b.to_string();
+            let a_bytes = a.as_bytes();
+            let b_bytes = b.as_bytes();
+
+            match a_bytes.len().cmp(&b_bytes.len()) {
+                std::cmp::Ordering::Equal => a_bytes.cmp(b_bytes),
+                other => other,
+            }
+        });
+
+        let collaborators = Collaborators::from(cat_ids.clone());
+        let mut e = Encoder::new(Vec::new());
+        collaborators.encode(&mut e, &mut ()).unwrap();
+
+        let result = Collaborators::decode(&mut Decoder::new(e.into_writer().as_slice()), &mut ());
+        assert!(result.is_ok());
+
+        let mut e = Encoder::new(Vec::new());
+        cat_ids.reverse();
+        let collaborators = Collaborators::from(cat_ids.clone());
+        collaborators.encode(&mut e, &mut ()).unwrap();
+
+        let result = Collaborators::decode(&mut Decoder::new(e.into_writer().as_slice()), &mut ());
+        assert!(result.is_err());
+    }
 }

rust/signed_doc/src/metadata/document_refs/mod.rs

@@ -86,7 +86,7 @@ impl Decode<'_, CompatibilityPolicy> for DocumentRefs {
 
         // Old: [id, ver]
         // New: [ 1* [id, ver, locator] ]
-        let outer_arr = Array::decode(d, &mut DecodeCtx::Deterministic)
+        let outer_arr = Array::decode(d, &mut DecodeCtx::ArrayDeterministic)
             .map_err(|e| minicbor::decode::Error::message(format!("{CONTEXT}: {e}")))?;
 
         match outer_arr.as_slice() {
@@ -355,4 +355,45 @@ pub(crate) mod tests {
 
         assert_eq!(refs, refs_from_json);
     }
+
+    #[test]
+    fn test_deterministic_decoding() {
+        let mut refs = vec![create_dummy_doc_ref(), create_dummy_doc_ref()];
+        refs.sort_by(|a, b| {
+            let a_bytes = {
+                let mut e = Encoder::new(Vec::new());
+                a.encode(&mut e, &mut ()).unwrap();
+                e.into_writer()
+            };
+            let b_bytes = {
+                let mut e = Encoder::new(Vec::new());
+                b.encode(&mut e, &mut ()).unwrap();
+                e.into_writer()
+            };
+
+            match a_bytes.len().cmp(&b_bytes.len()) {
+                std::cmp::Ordering::Equal => a_bytes.as_slice().cmp(&b_bytes),
+                other => other,
+            }
+        });
+
+        let mut e = Encoder::new(Vec::new());
+        refs.encode(&mut e, &mut ()).unwrap();
+
+        let result = DocumentRefs::decode(
+            &mut Decoder::new(e.into_writer().as_slice()),
+            &mut CompatibilityPolicy::Fail,
+        );
+        assert!(result.is_ok());
+
+        let mut e = Encoder::new(Vec::new());
+        refs.reverse();
+        refs.encode(&mut e, &mut ()).unwrap();
+
+        let result = DocumentRefs::decode(
+            &mut Decoder::new(e.into_writer().as_slice()),
+            &mut CompatibilityPolicy::Fail,
+        );
+        assert!(result.is_err());
+    }
 }