refactor custom predicates

Author: ed255

src/backends/plonky2/mock/mainpod/statement.rs

@@ -4,7 +4,7 @@ use anyhow::{anyhow, Result};
 
 // use serde::{Deserialize, Serialize};
 use crate::middleware::{
-    self, AnchoredKey, NativePredicate, Params, Predicate, StatementArg, ToFields,
+    self, AnchoredKey, NativePredicate, Params, Predicate, StatementArg, ToFields, WildcardValue,
 };
 
 #[derive(Clone, Debug, PartialEq)]
@@ -81,15 +81,15 @@ impl TryFrom<Statement> for middleware::Statement {
                 _ => Err(anyhow!("Ill-formed statement expression {:?}", s))?,
             },
             Predicate::Custom(cpr) => {
-                let aks: Vec<AnchoredKey> = proper_args
+                let vs: Vec<WildcardValue> = proper_args
                     .into_iter()
                     .filter_map(|arg| match arg {
                         SA::None => None,
-                        SA::Key(ak) => Some(ak),
-                        SA::Literal(_) => unreachable!(),
+                        SA::WildcardLiteral(v) => Some(v),
+                        _ => unreachable!(),
                     })
                     .collect();
-                S::Custom(cpr, aks)
+                S::Custom(cpr, vs)
             }
             Predicate::BatchSelf(_) => {
                 unreachable!()

src/examples/custom.rs

@@ -4,7 +4,7 @@ use anyhow::Result;
 use StatementTmplBuilder as STB;
 
 use crate::{
-    frontend::{literal, CustomPredicateBatchBuilder, StatementTmplBuilder},
+    frontend::{key, literal, CustomPredicateBatchBuilder, StatementTmplBuilder},
     middleware::{
         self, CustomPredicateBatch, CustomPredicateRef, NativePredicate as NP, Params, PodType,
         Predicate, KEY_SIGNER, KEY_TYPE,
@@ -25,15 +25,15 @@ pub fn eth_friend_batch(params: &Params) -> Result<Arc<CustomPredicateBatch>> {
         &[
             // there is an attestation pod that's a SignedPod
             STB::new(NP::ValueOf)
-                .arg(("attestation_pod", literal(KEY_TYPE)))
-                .arg(PodType::MockSigned), // TODO
+                .arg(("attestation_pod", key(KEY_TYPE)))
+                .arg(literal(PodType::MockSigned)), // TODO
             // the attestation pod is signed by (src_or, src_key)
             STB::new(NP::Equal)
-                .arg(("attestation_pod", literal(KEY_SIGNER)))
+                .arg(("attestation_pod", key(KEY_SIGNER)))
                 .arg(("src_ori", "src_key")),
             // that same attestation pod has an "attestation"
             STB::new(NP::Equal)
-                .arg(("attestation_pod", literal("attestation")))
+                .arg(("attestation_pod", key("attestation")))
                 .arg(("dst_ori", "dst_key")),
         ],
     )?;
@@ -72,7 +72,7 @@ pub fn eth_dos_batch(params: &Params) -> Result<Arc<CustomPredicateBatch>> {
                 .arg(("dst_ori", "dst_key")),
             STB::new(NP::ValueOf)
                 .arg(("distance_ori", "distance_key"))
-                .arg(0),
+                .arg(literal(0)),
         ],
     )?;
     println!(
@@ -106,19 +106,26 @@ pub fn eth_dos_batch(params: &Params) -> Result<Arc<CustomPredicateBatch>> {
         &[
             // statement templates:
             STB::new(eth_dos_distance)
-                .arg(("src_ori", "src_key"))
-                .arg(("intermed_ori", "intermed_key"))
-                .arg(("shorter_distance_ori", "shorter_distance_key")),
+                .arg("src_ori")
+                .arg("src_key")
+                .arg("intermed_ori")
+                .arg("intermed_key")
+                .arg("shorter_distance_ori")
+                .arg("shorter_distance_key"),
             // distance == shorter_distance + 1
-            STB::new(NP::ValueOf).arg(("one_ori", "one_key")).arg(1),
+            STB::new(NP::ValueOf)
+                .arg(("one_ori", "one_key"))
+                .arg(literal(1)),
             STB::new(NP::SumOf)
                 .arg(("distance_ori", "distance_key"))
                 .arg(("shorter_distance_ori", "shorter_distance_key"))
                 .arg(("one_ori", "one_key")),
             // intermed is a friend of dst
             STB::new(eth_friend)
-                .arg(("intermed_ori", "intermed_key"))
-                .arg(("dst_ori", "dst_key")),
+                .arg("intermed_ori")
+                .arg("intermed_key")
+                .arg("dst_ori")
+                .arg("dst_key"),
         ],
     )?;
 
@@ -141,13 +148,19 @@ pub fn eth_dos_batch(params: &Params) -> Result<Arc<CustomPredicateBatch>> {
         &[],
         &[
             STB::new(eth_dos_distance_base)
-                .arg(("src_ori", "src_key"))
-                .arg(("dst_ori", "dst_key"))
-                .arg(("distance_ori", "distance_key")),
+                .arg("src_ori")
+                .arg("src_key")
+                .arg("dst_ori")
+                .arg("dst_key")
+                .arg("distance_ori")
+                .arg("distance_key"),
             STB::new(eth_dos_distance_ind)
-                .arg(("src_ori", "src_key"))
-                .arg(("dst_ori", "dst_key"))
-                .arg(("distance_ori", "distance_key")),
+                .arg("src_ori")
+                .arg("src_key")
+                .arg("dst_ori")
+                .arg("dst_key")
+                .arg("distance_ori")
+                .arg("distance_key"),
         ],
     )?;
 

src/examples/mod.rs

@@ -139,7 +139,8 @@ pub fn eth_dos_pod_builder(
     let ethdos_alice_alice_is_zero = alice_bob_ethdos.priv_op(op!(
         custom,
         eth_dos.clone(),
-        ethdos_alice_alice_is_zero_base
+        ethdos_alice_alice_is_zero_base,
+        Statement::None
     ))?;
 
     // Alice and Charlie are ETH friends.
@@ -192,6 +193,7 @@ pub fn eth_dos_pod_builder(
     let ethdos_alice_charlie_is_one = alice_bob_ethdos.priv_op(op!(
         custom,
         eth_dos.clone(),
+        Statement::None,
         ethdos_alice_charlie_is_one_ind
     ))?;
 
@@ -210,8 +212,12 @@ pub fn eth_dos_pod_builder(
         ethdos_sum,
         ethfriends_charlie_bob
     ))?;
-    let _ethdos_alice_bob_is_two =
-        alice_bob_ethdos.pub_op(op!(custom, eth_dos.clone(), ethdos_alice_bob_is_two_ind))?;
+    let _ethdos_alice_bob_is_two = alice_bob_ethdos.pub_op(op!(
+        custom,
+        eth_dos.clone(),
+        Statement::None,
+        ethdos_alice_bob_is_two_ind
+    ))?;
 
     Ok(alice_bob_ethdos)
 }

src/frontend/custom.rs

@@ -22,27 +22,28 @@ pub enum KeyOrWildcardStr {
 }
 
 /// helper to build a literal KeyOrWildcardStr::Key from the given str
-pub fn literal(s: &str) -> KeyOrWildcardStr {
+pub fn key(s: &str) -> KeyOrWildcardStr {
     KeyOrWildcardStr::Key(s.to_string())
 }
 
 /// helper to build a KeyOrWildcardStr::Wildcard from the given str. For the
 /// moment this method does not need to be public.
-fn wildcard(s: &str) -> KeyOrWildcardStr {
-    KeyOrWildcardStr::Wildcard(s.to_string())
-}
+// fn wildcard(s: &str) -> KeyOrWildcardStr {
+//     KeyOrWildcardStr::Wildcard(s.to_string())
+// }
 
 /// Builder Argument for the StatementTmplBuilder
 pub enum BuilderArg {
     Literal(Value),
     /// Key: (origin, key), where origin is a Wildcard and key can be both Key or Wildcard
     Key(String, KeyOrWildcardStr),
+    WildcardLiteral(String),
 }
 
 /// When defining a `BuilderArg`, it can be done from 3 different inputs:
 ///   i. (&str, literal): this is to set a POD and a field, ie. (POD, literal("field"))
 ///  ii. (&str, &str): this is to define a origin-key wildcard pair, ie. (src_origin, src_dest)
-/// iii. Value: this is to define a literal value, ie. 0
+/// iii. &str: this is to define a WildcardValue wildcard, ie. "src_or"
 ///
 /// case i.
 impl From<(&str, KeyOrWildcardStr)> for BuilderArg {
@@ -58,19 +59,20 @@ impl From<(&str, KeyOrWildcardStr)> for BuilderArg {
 /// case ii.
 impl From<(&str, &str)> for BuilderArg {
     fn from((origin, field): (&str, &str)) -> Self {
-        Self::Key(origin.into(), wildcard(field))
+        Self::Key(origin.into(), KeyOrWildcardStr::Wildcard(field.to_string()))
     }
 }
 /// case iii.
-impl<V> From<V> for BuilderArg
-where
-    V: Into<Value>,
-{
-    fn from(v: V) -> Self {
-        Self::Literal(v.into())
+impl From<&str> for BuilderArg {
+    fn from(wc: &str) -> Self {
+        Self::WildcardLiteral(wc.to_string())
     }
 }
 
+pub fn literal(v: impl Into<Value>) -> BuilderArg {
+    BuilderArg::Literal(v.into())
+}
+
 pub struct StatementTmplBuilder {
     predicate: Predicate,
     args: Vec<BuilderArg>,
@@ -136,6 +138,21 @@ impl CustomPredicateBatchBuilder {
         priv_args: &[&str],
         sts: &[StatementTmplBuilder],
     ) -> Result<Predicate> {
+        if args.len() > params.max_statement_args {
+            return Err(anyhow!(
+                "args.len {} is over the limit {}",
+                args.len(),
+                params.max_statement_args
+            ));
+        }
+        if (args.len() + priv_args.len()) > params.max_custom_predicate_wildcards {
+            return Err(anyhow!(
+                "wildcards.len {} is over the limit {}",
+                args.len() + priv_args.len(),
+                params.max_custom_predicate_wildcards
+            ));
+        }
+
         let statements = sts
             .iter()
             .map(|sb| {
@@ -148,6 +165,9 @@ impl CustomPredicateBatchBuilder {
                             resolve_wildcard(args, priv_args, &pod_id),
                             resolve_key_or_wildcard(args, priv_args, &key),
                         ),
+                        BuilderArg::WildcardLiteral(v) => {
+                            StatementTmplArg::WildcardLiteral(resolve_wildcard(args, priv_args, &v))
+                        }
                     })
                     .collect();
                 StatementTmpl {