refactor(dataverse): reoganize vc related code

contracts/okp4-dataverse/src/credential/mod.rs

@@ -0,0 +1,3 @@
+mod proof;
+mod rdf_markers;
+mod vc;

contracts/okp4-dataverse/src/did/crypto.rs → contracts/okp4-dataverse/src/credential/proof.rs

@@ -1,4 +1,4 @@
-use crate::did::consts::RDF_TYPE;
+use crate::credential::rdf_markers::RDF_TYPE;
 use crate::ContractError;
 use itertools::Itertools;
 use okp4_rdf::dataset::{Dataset, QuadIterator};

contracts/okp4-dataverse/src/did/vc.rs → contracts/okp4-dataverse/src/credential/vc.rs

@@ -1,9 +1,9 @@
-use crate::did::consts::*;
-use crate::did::crypto::Proof;
+use crate::credential::proof::Proof;
+use crate::credential::rdf_markers::*;
 use crate::ContractError;
 use itertools::Itertools;
+use okp4_rdf::dataset::Dataset;
 use okp4_rdf::dataset::QuadIterator;
-use okp4_rdf::dataset::{Dataset, QuadPattern};
 use rio_api::model::{BlankNode, Literal, NamedNode, Subject, Term};
 
 pub struct VerifiableCredential<'a> {
@@ -35,12 +35,13 @@ impl<'a> TryFrom<&'a Dataset<'a>> for VerifiableCredential<'a> {
     fn try_from(dataset: &'a Dataset<'a>) -> Result<Self, Self::Error> {
         let id = Self::extract_identifier(&dataset)?;
 
-        let mut proofs = vec![];
-        let mut unsecured_filter: Vec<QuadPattern<'_>> = vec![];
-        for (proof, graph) in Self::extract_proofs(dataset, id)? {
-            proofs.push(proof);
-            unsecured_filter.push((None, None, None, Some(Some(graph.into()))).into())
-        }
+        let (proofs, proof_graphs): (Vec<Proof<'a>>, Vec<BlankNode<'a>>) =
+            Self::extract_proofs(dataset, id)?.into_iter().unzip();
+
+        let unsecured_filter = proof_graphs
+            .into_iter()
+            .map(|g| (None, None, None, Some(Some(g.into()))).into())
+            .collect();
 
         Ok(Self {
             id: id.iri,
@@ -53,7 +54,7 @@ impl<'a> TryFrom<&'a Dataset<'a>> for VerifiableCredential<'a> {
             proof: proofs,
             unsecured_document: Dataset::new(
                 dataset
-                    .into_iter()
+                    .iter()
                     .skip_patterns(unsecured_filter)
                     .map(|quad| *quad)
                     .collect(),

contracts/okp4-dataverse/src/lib.rs

@@ -11,7 +11,7 @@
 )]
 
 pub mod contract;
-mod did;
+mod credential;
 mod error;
 pub mod msg;
 pub mod state;

packages/okp4-rdf/src/dataset.rs

@@ -12,14 +12,18 @@ impl<'a> Dataset<'a> {
         Self { quads }
     }
 
+    pub fn iter(&self) -> Iter<Quad<'a>> {
+        self.quads.iter()
+    }
+
     pub fn match_pattern(
         &'a self,
         s: Option<Subject<'a>>,
         p: Option<NamedNode<'a>>,
         o: Option<Term<'a>>,
         g: Option<Option<GraphName<'a>>>,
     ) -> QuadPatternFilter<'a, Iter<'a, Quad<'a>>> {
-        self.quads.iter().match_pattern((s, p, o, g).into())
+        self.iter().match_pattern((s, p, o, g).into())
     }
 
     pub fn skip_pattern(
@@ -29,7 +33,7 @@ impl<'a> Dataset<'a> {
         o: Option<Term<'a>>,
         g: Option<Option<GraphName<'a>>>,
     ) -> QuadPatternFilter<'a, Iter<'a, Quad<'a>>> {
-        self.quads.iter().skip_pattern((s, p, o, g).into())
+        self.iter().skip_pattern((s, p, o, g).into())
     }
 }
 
@@ -41,15 +45,6 @@ impl<'a> From<&'a [Quad<'a>]> for Dataset<'a> {
     }
 }
 
-impl<'a> IntoIterator for &'a Dataset<'a> {
-    type Item = &'a Quad<'a>;
-    type IntoIter = Iter<'a, Quad<'a>>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.quads.iter()
-    }
-}
-
 #[derive(Copy, Clone)]
 pub struct QuadPattern<'a> {
     subject: Option<Subject<'a>>,