Fix remaining tests

Author: ax0

src/backends/plonky2/mock_main/mod.rs

@@ -523,13 +523,16 @@ pub mod tests {
         zu_kyc_sign_pod_builders,
     };
     use crate::middleware;
+    use crate::middleware::containers::Set;
 
     #[test]
     fn test_mock_main_zu_kyc() -> Result<()> {
         let params = middleware::Params::default();
+        let sanctions_values = ["A343434340"].map(|s| crate::middleware::Value::from(hash_str(s)));
+        let sanction_set = Set::new(&sanctions_values.to_vec()).unwrap();
 
         let (gov_id_builder, pay_stub_builder, sanction_list_builder) =
-            zu_kyc_sign_pod_builders(&params);
+            zu_kyc_sign_pod_builders(&params, &sanction_set);
         let mut signer = MockSigner {
             pk: "ZooGov".into(),
         };
@@ -542,8 +545,13 @@ pub mod tests {
             pk: "ZooOFAC".into(),
         };
         let sanction_list_pod = sanction_list_builder.sign(&mut signer)?;
-        let kyc_builder =
-            zu_kyc_pod_builder(&params, &gov_id_pod, &pay_stub_pod, &sanction_list_pod)?;
+        let kyc_builder = zu_kyc_pod_builder(
+            &params,
+            &gov_id_pod,
+            &pay_stub_pod,
+            &sanction_list_pod,
+            &sanction_set,
+        )?;
 
         let mut prover = MockProver {};
         let kyc_pod = kyc_builder.prove(&mut prover, &params)?;

src/examples.rs

@@ -17,6 +17,7 @@ use crate::op;
 
 pub fn zu_kyc_sign_pod_builders(
     params: &Params,
+    sanction_set: &Set,
 ) -> (SignedPodBuilder, SignedPodBuilder, SignedPodBuilder) {
     let mut gov_id = SignedPodBuilder::new(params);
     gov_id.insert("idNumber", "4242424242");
@@ -28,11 +29,7 @@ pub fn zu_kyc_sign_pod_builders(
     pay_stub.insert("startDate", 1706367566);
 
     let mut sanction_list = SignedPodBuilder::new(params);
-    let sanctions_values = ["A343434340"].map(|s| crate::middleware::Value::from(hash_str(s)));
-    sanction_list.insert(
-        "sanctionList",
-        Value::Set(Set::new(&sanctions_values.to_vec()).unwrap()),
-    );
+    sanction_list.insert("sanctionList", Value::Set(sanction_set.clone()));
 
     (gov_id, pay_stub, sanction_list)
 }
@@ -42,18 +39,23 @@ pub fn zu_kyc_pod_builder(
     gov_id: &SignedPod,
     pay_stub: &SignedPod,
     sanction_list: &SignedPod,
+    sanction_set: &Set,
 ) -> Result<MainPodBuilder> {
     let now_minus_18y: i64 = 1169909388;
     let now_minus_1y: i64 = 1706367566;
 
+    let gov_id_kvs = gov_id.kvs();
+    let id_number_value = gov_id_kvs.get(&"idNumber".into()).unwrap();
+
     let mut kyc = MainPodBuilder::new(params);
     kyc.add_signed_pod(gov_id);
     kyc.add_signed_pod(pay_stub);
     kyc.add_signed_pod(sanction_list);
     kyc.pub_op(op!(
         not_contains,
         (sanction_list, "sanctionList"),
-        (gov_id, "idNumber")
+        (gov_id, "idNumber"),
+        sanction_set.prove_nonexistence(id_number_value)?
     ))?;
     kyc.pub_op(op!(lt, (gov_id, "dateOfBirth"), now_minus_18y))?;
     kyc.pub_op(op!(
@@ -223,7 +225,7 @@ pub fn great_boy_pod_builder(
     params: &Params,
     good_boy_pods: [&SignedPod; 4],
     friend_pods: [&SignedPod; 2],
-    good_boy_issuers: &Value,
+    good_boy_issuer_dict: &Dictionary,
     receiver: &str,
 ) -> Result<MainPodBuilder> {
     // Attestment chain (issuer -> good boy -> great boy):
@@ -250,6 +252,8 @@ pub fn great_boy_pod_builder(
             PodType::MockSigned as i64
         ))?;
         for issuer_idx in 0..2 {
+            let pod_kvs = good_boy_pods[good_boy_idx * 2 + issuer_idx].kvs();
+
             // Type check
             great_boy.pub_op(op!(
                 eq,
@@ -259,9 +263,12 @@ pub fn great_boy_pod_builder(
             // Each good boy POD comes from a valid issuer
             great_boy.pub_op(op!(
                 contains,
-                good_boy_issuers,
+                Value::Dictionary(good_boy_issuer_dict.clone()),
                 (good_boy_pods[good_boy_idx * 2 + issuer_idx], KEY_SIGNER),
-                0
+                0,
+                good_boy_issuer_dict
+                    .prove(pod_kvs.get(&KEY_SIGNER.into()).unwrap())?
+                    .1
             ))?;
             // Each good boy has 2 good boy pods
             great_boy.pub_op(op!(
@@ -338,7 +345,13 @@ pub fn great_boy_pod_full_flow() -> Result<MainPodBuilder> {
     alice_friend_pods.push(friend.sign(&mut bob_signer).unwrap());
     alice_friend_pods.push(friend.sign(&mut charlie_signer).unwrap());
 
-    let good_boy_issuers_dict = Value::Dictionary(Dictionary::new(&HashMap::new())?); // empty
+    let good_boy_issuer_dict = Dictionary::new(
+        &good_boy_issuers
+            .into_iter()
+            .map(|issuer| (crate::middleware::Hash::from(issuer), 0.into()))
+            .collect(),
+    )?;
+
     great_boy_pod_builder(
         &params,
         [
@@ -348,7 +361,7 @@ pub fn great_boy_pod_full_flow() -> Result<MainPodBuilder> {
             &charlie_good_boys[1],
         ],
         [&alice_friend_pods[0], &alice_friend_pods[1]],
-        &good_boy_issuers_dict,
+        &good_boy_issuer_dict,
         alice,
     )
 }
@@ -374,7 +387,7 @@ pub fn tickets_pod_builder(
     expect_consumed: bool,
     blacklisted_emails: &Dictionary,
 ) -> Result<MainPodBuilder> {
-    let blacklisted_email_root = Value::Dictionary(blacklisted_emails.clone());
+    let blacklisted_email_dict_value = Value::Dictionary(blacklisted_emails.clone());
     let attendee_email_statement: Statement = (signed_pod, "attendeeEmail").into();
     let attendee_email_value = match attendee_email_statement.1.get(1).cloned() {
         Some(crate::frontend::StatementArg::Literal(v)) => Ok(v),
@@ -390,7 +403,7 @@ pub fn tickets_pod_builder(
     builder.pub_op(op!(eq, (signed_pod, "isRevoked"), false))?;
     builder.pub_op(op!(
         not_contains,
-        blacklisted_email_root,
+        blacklisted_email_dict_value,
         attendee_email_statement,
         blacklisted_emails.prove_nonexistence(&(&attendee_email_value).into())?
     ))?;

src/frontend/mod.rs

@@ -85,6 +85,12 @@ impl From<middleware::Value> for Value {
     }
 }
 
+impl From<middleware::Hash> for Value {
+    fn from(v: middleware::Hash) -> Self {
+        Self::Raw(v.into())
+    }
+}
+
 impl TryInto<i64> for Value {
     type Error = Error;
     fn try_into(self) -> std::result::Result<i64, Self::Error> {
@@ -995,7 +1001,9 @@ pub mod tests {
     #[test]
     fn test_front_zu_kyc() -> Result<()> {
         let params = Params::default();
-        let (gov_id, pay_stub, sanction_list) = zu_kyc_sign_pod_builders(&params);
+        let sanctions_values = ["A343434340"].map(|s| crate::middleware::Value::from(hash_str(s)));
+        let sanction_set = Set::new(&sanctions_values).unwrap();
+        let (gov_id, pay_stub, sanction_list) = zu_kyc_sign_pod_builders(&params, &sanction_set);
 
         println!("{}", gov_id);
         println!("{}", pay_stub);
@@ -1021,7 +1029,8 @@ pub mod tests {
         check_kvs(&sanction_list)?;
         println!("{}", sanction_list);
 
-        let kyc_builder = zu_kyc_pod_builder(&params, &gov_id, &pay_stub, &sanction_list)?;
+        let kyc_builder =
+            zu_kyc_pod_builder(&params, &gov_id, &pay_stub, &sanction_list, &sanction_set)?;
         println!("{}", kyc_builder);
 
         // prove kyc with MockProver and print it
@@ -1177,8 +1186,9 @@ pub mod tests {
         my_dict_kvs.insert(BeValue::from(&"b".into()), BeValue::from(&2.into()));
         my_dict_kvs.insert(BeValue::from(&"c".into()), BeValue::from(&3.into()));
         let my_dict_as_mt = MerkleTree::new(5, &my_dict_kvs).unwrap();
-        let dict = Value::Dictionary(Dictionary { mt: my_dict_as_mt });
-        builder.insert("dict", dict);
+        let dict = Dictionary { mt: my_dict_as_mt };
+        let dict_root = Value::Dictionary(dict.clone());
+        builder.insert("dict", dict_root);
 
         let mut signer = MockSigner {
             pk: "signer".into(),
@@ -1200,6 +1210,7 @@ pub mod tests {
                     OperationArg::Statement(st0),
                     OperationArg::Statement(st1),
                     OperationArg::Statement(st2),
+                    OperationArg::MerkleProof(dict.prove(&Hash::from("a").into()).unwrap().1),
                 ],
             ))
             .unwrap();

src/middleware/containers.rs

@@ -73,7 +73,7 @@ pub struct Set {
 }
 
 impl Set {
-    pub fn new(set: &Vec<Value>) -> Result<Self> {
+    pub fn new(set: &[Value]) -> Result<Self> {
         let kvs: HashMap<Value, Value> = set
             .iter()
             .map(|e| {
@@ -126,7 +126,7 @@ pub struct Array {
 }
 
 impl Array {
-    pub fn new(array: &Vec<Value>) -> Result<Self> {
+    pub fn new(array: &[Value]) -> Result<Self> {
         let kvs: HashMap<Value, Value> = array
             .iter()
             .enumerate()