Incorporate Merkle proof op arg into frontend

Author: ax0

src/examples.rs

@@ -372,8 +372,16 @@ pub fn tickets_pod_builder(
     signed_pod: &SignedPod,
     expected_event_id: i64,
     expect_consumed: bool,
-    blacklisted_emails: &Value,
+    blacklisted_emails: &Dictionary,
 ) -> Result<MainPodBuilder> {
+    let blacklisted_email_root = 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),
+        _ => Err(anyhow!(
+            "Unexpected error reading attendee email from signed POD."
+        )),
+    }?;
     // Create a main pod referencing this signed pod with some statements
     let mut builder = MainPodBuilder::new(params);
     builder.add_signed_pod(signed_pod);
@@ -382,8 +390,9 @@ pub fn tickets_pod_builder(
     builder.pub_op(op!(eq, (signed_pod, "isRevoked"), false))?;
     builder.pub_op(op!(
         not_contains,
-        blacklisted_emails,
-        (signed_pod, "attendeeEmail")
+        blacklisted_email_root,
+        attendee_email_statement,
+        blacklisted_emails.prove_nonexistence(&(&attendee_email_value).into())?
     ))?;
     Ok(builder)
 }
@@ -397,6 +406,6 @@ pub fn tickets_pod_full_flow() -> Result<MainPodBuilder> {
         &signed_pod,
         123,
         true,
-        &Value::Dictionary(Dictionary::new(&HashMap::new())?),
+        &Dictionary::new(&HashMap::new())?,
     )
 }

src/frontend/mod.rs

@@ -343,6 +343,8 @@ impl MainPodBuilder {
                     )));
                     st_args.push(StatementArg::Literal(v.clone()))
                 }
+                // Merkle proofs are never arguments to statements.
+                OperationArg::MerkleProof(_) => (),
             };
         }
         Ok(st_args)
@@ -802,9 +804,12 @@ impl MainPodCompiler {
         self.operations.push(op);
     }
 
-    fn compile_op_arg(&self, op_arg: &OperationArg) -> Option<middleware::Statement> {
+    fn compile_op_arg(&self, op_arg: &OperationArg) -> Option<middleware::OperationArg> {
         match op_arg {
-            OperationArg::Statement(s) => self.compile_st(s).ok(),
+            OperationArg::Statement(s) => self
+                .compile_st(s)
+                .ok()
+                .map(|s| middleware::OperationArg::Statement(s)),
             OperationArg::Literal(_v) => {
                 // OperationArg::Literal is a syntax sugar for the frontend.  This is translated to
                 // a new ValueOf statement and it's key used instead.
@@ -816,6 +821,9 @@ impl MainPodCompiler {
                 // statement doesn't have any requirement on the key and value.
                 None
             }
+            OperationArg::MerkleProof(pf) => {
+                Some(middleware::OperationArg::MerkleProof(pf.clone()))
+            }
         }
     }
 
@@ -829,10 +837,7 @@ impl MainPodCompiler {
         // TODO: Take Merkle proof into account.
         let mop_args =
             op.1.iter()
-                .flat_map(|arg| {
-                    self.compile_op_arg(arg)
-                        .map(|s| Ok(middleware::OperationArg::Statement(s.try_into()?)))
-                })
+                .flat_map(|arg| self.compile_op_arg(arg).map(|op_arg| Ok(op_arg)))
                 .collect::<Result<Vec<_>>>()?;
         middleware::Operation::op(mop_code, &mop_args)
     }

src/frontend/operation.rs

@@ -1,13 +1,14 @@
 use std::fmt;
 
 use super::{SignedPod, Statement, Value};
-use crate::middleware::OperationType;
+use crate::{backends::plonky2::primitives::merkletree::MerkleProof, middleware::OperationType};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum OperationArg {
     Statement(Statement),
     Literal(Value),
     Entry(String, Value),
+    MerkleProof(MerkleProof),
 }
 
 impl fmt::Display for OperationArg {
@@ -16,6 +17,7 @@ impl fmt::Display for OperationArg {
             OperationArg::Statement(s) => write!(f, "{}", s),
             OperationArg::Literal(v) => write!(f, "{}", v),
             OperationArg::Entry(k, v) => write!(f, "({}, {})", k, v),
+            OperationArg::MerkleProof(pf) => write!(f, "merkle_proof({})", pf),
         }
     }
 }
@@ -68,6 +70,12 @@ impl<V: Into<Value>> From<(&str, V)> for OperationArg {
     }
 }
 
+impl From<MerkleProof> for OperationArg {
+    fn from(pf: MerkleProof) -> Self {
+        Self::MerkleProof(pf)
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Operation(pub OperationType, pub Vec<OperationArg>);