feat: add middleware and signer traits (#18)

* feat: add middleware and signer traits

* wip

* wip

* feat: MainPod traits

Author: ed255

Cargo.toml

@@ -14,3 +14,4 @@ itertools = "0.14.0"
 strum = "0.26"
 strum_macros = "0.26"
 anyhow = "1.0.56"
+dyn-clone = "1.0.18"

src/backend.rs

@@ -1,71 +1,15 @@
+// TODO: Move the SignedPod.id calculation to mock_signed
+// TODO: Move the MainPod logic to mock_main and implement the MainPod trait
+/*
 use anyhow::Result;
 use itertools::Itertools;
 use plonky2::field::types::{Field, PrimeField64};
 use std::collections::HashMap;
-use std::fmt;
 use std::io::{self, Write};
 use std::iter;
-use strum_macros::FromRepr;
 
-use crate::{merkletree::MerkleTree, Hash, Params, PodId, F, NULL};
-
-#[derive(Clone, Copy, Debug, FromRepr, PartialEq, Eq)]
-pub enum NativeStatement {
-    None = 0,
-    ValueOf = 1,
-    Equal = 2,
-    NotEqual,
-    Gt,
-    Lt,
-    Contains,
-    NotContains,
-    SumOf,
-    ProductOf,
-    MaxOf,
-}
-
-#[derive(Clone, Copy, Debug, Default, Hash, PartialEq, Eq)]
-pub struct Value(pub [F; 4]);
-
-impl fmt::Display for Value {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if self.0[2].is_zero() && self.0[3].is_zero() {
-            // Assume this is an integer
-            let (l0, l1) = (self.0[0].to_canonical_u64(), self.0[1].to_canonical_u64());
-            assert!(l0 < (1 << 32));
-            assert!(l1 < (1 << 32));
-            write!(f, "{}", l0 + l1 * (1 << 32))
-        } else {
-            // Assume this is a hash
-            Hash(self.0).fmt(f)
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct AnchoredKey(pub PodId, pub Hash);
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum StatementArg {
-    None,
-    Literal(Value),
-    Ref(AnchoredKey),
-}
-
-impl StatementArg {
-    pub fn is_none(&self) -> bool {
-        matches!(self, Self::None)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Statement(pub NativeStatement, pub Vec<StatementArg>);
-
-impl Statement {
-    pub fn is_none(&self) -> bool {
-        matches!(self.0, NativeStatement::None)
-    }
-}
+use crate::merkletree::MerkleTree;
+use crate::middleware::{Hash, Params, PodId, Value, NULL};
 
 #[derive(Clone, Debug)]
 pub struct SignedPod {
@@ -306,3 +250,4 @@ mod tests {
         Ok(())
     }
 }
+*/

src/backends.rs

@@ -0,0 +1,3 @@
+pub mod mock_main;
+pub mod mock_signed;
+pub mod plonky2;

src/backends/mock_main.rs

@@ -0,0 +1,124 @@
+use crate::middleware::{
+    hash_str, Hash, Params, PodId, PodSigner, PodType, SignedPod, Value, KEY_SIGNER, KEY_TYPE,
+};
+use itertools::Itertools;
+use std::any::Any;
+use std::collections::HashMap;
+
+pub struct MockSigner {
+    pub pk: String,
+}
+
+fn calculate_pod_id(kvs: &HashMap<Hash, Value>) -> PodId {
+    let mut s = String::new();
+    for (k, v) in kvs.iter().sorted_by_key(|kv| kv.0) {
+        s += &format!("{}:{},", k, v);
+    }
+    PodId(hash_str(&s))
+}
+
+impl PodSigner for MockSigner {
+    fn sign(&mut self, _params: &Params, kvs: &HashMap<Hash, Value>) -> Box<dyn SignedPod> {
+        let mut kvs = kvs.clone();
+        let pk_hash = hash_str(&self.pk);
+        kvs.insert(hash_str(&KEY_SIGNER), Value(pk_hash.0));
+        kvs.insert(hash_str(&KEY_TYPE), Value::from(PodType::MockSigned));
+
+        let id = calculate_pod_id(&kvs);
+        let signature = format!("{}_signed_by_{}", id, pk_hash);
+        Box::new(MockSignedPod {
+            kvs: kvs.clone(),
+            id,
+            signature,
+        })
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct MockSignedPod {
+    pub id: PodId,
+    pub signature: String,
+    pub kvs: HashMap<Hash, Value>,
+}
+
+impl SignedPod for MockSignedPod {
+    fn verify(&self) -> bool {
+        // Verify type
+        if Some(&Value::from(PodType::MockSigned)) != self.kvs.get(&hash_str(&KEY_TYPE)) {
+            return false;
+        }
+
+        // Verify id
+        let id = calculate_pod_id(&self.kvs);
+        if id != self.id {
+            return false;
+        }
+
+        // Verify signature
+        let pk_hash = match self.kvs.get(&hash_str(&KEY_SIGNER)) {
+            Some(v) => v,
+            None => return false,
+        };
+        let signature = format!("{}_signed_by_{}", id, pk_hash);
+        if signature != self.signature {
+            return false;
+        }
+
+        return true;
+    }
+
+    fn id(&self) -> PodId {
+        self.id
+    }
+
+    fn kvs(&self) -> HashMap<Hash, Value> {
+        self.kvs.clone()
+    }
+
+    fn into_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+    use crate::frontend;
+    use crate::middleware::{self, F, NULL};
+    use plonky2::field::types::Field;
+
+    #[test]
+    fn test_mock_signed_0() {
+        let params = middleware::Params::default();
+        let mut pod = frontend::SignedPodBuilder::new(&params);
+        pod.insert("idNumber", "4242424242");
+        pod.insert("dateOfBirth", 1169909384);
+        pod.insert("socialSecurityNumber", "G2121210");
+
+        let mut signer = MockSigner { pk: "Molly".into() };
+        let pod = pod.sign(&mut signer);
+        let pod = pod.pod.into_any().downcast::<MockSignedPod>().unwrap();
+
+        assert_eq!(pod.verify(), true);
+        println!("id: {}", pod.id());
+        println!("kvs: {:?}", pod.kvs());
+
+        let mut bad_pod = pod.clone();
+        bad_pod.signature = "".into();
+        assert_eq!(bad_pod.verify(), false);
+
+        let mut bad_pod = pod.clone();
+        bad_pod.id.0 .0[0] = F::ZERO;
+        assert_eq!(bad_pod.verify(), false);
+
+        let mut bad_pod = pod.clone();
+        bad_pod
+            .kvs
+            .insert(hash_str(KEY_SIGNER), Value(PodId(NULL).0 .0));
+        assert_eq!(bad_pod.verify(), false);
+
+        let mut bad_pod = pod.clone();
+        bad_pod.kvs.insert(hash_str(KEY_TYPE), Value::from(0));
+        assert_eq!(bad_pod.verify(), false);
+    }
+}