diff --git a/examples/main_pod_points.rs b/examples/main_pod_points.rs index 37967cd..e60e9ed 100644 --- a/examples/main_pod_points.rs +++ b/examples/main_pod_points.rs @@ -15,10 +15,9 @@ use pod2::{ basetypes::DEFAULT_VD_SET, mainpod::Prover, mock::mainpod::MockProver, primitives::ec::schnorr::SecretKey, signedpod::Signer, }, - frontend::{MainPodBuilder, SignedPodBuilder}, + frontend::{MainPodBuilder, Operation, SignedPodBuilder}, lang::parse, middleware::{Params, PodProver, PodType, VDSet, Value, KEY_SIGNER, KEY_TYPE}, - op, }; fn main() -> Result<(), Box> { @@ -100,19 +99,17 @@ fn main() -> Result<(), Box> { // Build a pod to prove the statement `points("Alice", 1, 3512)` let mut builder = MainPodBuilder::new(¶ms, vd_set); builder.add_signed_pod(&pod_points_lvl_1); - let st_type = builder.priv_op(op!(eq, (&pod_points_lvl_1, KEY_TYPE), PodType::Signed))?; - let st_signer = builder.priv_op(op!(eq, (&pod_points_lvl_1, KEY_SIGNER), game_pk))?; - let st_player = builder.priv_op(op!(eq, (&pod_points_lvl_1, "player"), "Alice"))?; - let st_level = builder.priv_op(op!(eq, (&pod_points_lvl_1, "level"), 1))?; - let st_points = builder.priv_op(op!(eq, (&pod_points_lvl_1, "points"), 3512))?; - let st_points_lvl_1 = builder.pub_op(op!( - custom, + let st_type = builder.priv_op(Operation::eq( + (&pod_points_lvl_1, KEY_TYPE), + PodType::Signed, + ))?; + let st_signer = builder.priv_op(Operation::eq((&pod_points_lvl_1, KEY_SIGNER), game_pk))?; + let st_player = builder.priv_op(Operation::eq((&pod_points_lvl_1, "player"), "Alice"))?; + let st_level = builder.priv_op(Operation::eq((&pod_points_lvl_1, "level"), 1))?; + let st_points = builder.priv_op(Operation::eq((&pod_points_lvl_1, "points"), 3512))?; + let st_points_lvl_1 = builder.pub_op(Operation::custom( points_pred.clone(), - st_type, - st_signer, - st_player, - st_level, - st_points + [st_type, st_signer, st_player, st_level, st_points], ))?; let pod_alice_lvl_1_points = builder.prove(prover).unwrap(); println!("# pod_alice_lvl_1_points\n:{}", pod_alice_lvl_1_points); @@ -121,19 +118,17 @@ fn main() -> Result<(), Box> { // Build a pod to prove the statement `points("Alice", 2, 5771)` let mut builder = MainPodBuilder::new(¶ms, vd_set); builder.add_signed_pod(&pod_points_lvl_2); - let st_type = builder.priv_op(op!(eq, (&pod_points_lvl_2, KEY_TYPE), PodType::Signed))?; - let st_signer = builder.priv_op(op!(eq, (&pod_points_lvl_2, KEY_SIGNER), game_pk))?; - let st_player = builder.priv_op(op!(eq, (&pod_points_lvl_2, "player"), "Alice"))?; - let st_level = builder.priv_op(op!(eq, (&pod_points_lvl_2, "level"), 2))?; - let st_points = builder.priv_op(op!(eq, (&pod_points_lvl_2, "points"), 5771))?; - let st_points_lvl_2 = builder.pub_op(op!( - custom, + let st_type = builder.priv_op(Operation::eq( + (&pod_points_lvl_2, KEY_TYPE), + PodType::Signed, + ))?; + let st_signer = builder.priv_op(Operation::eq((&pod_points_lvl_2, KEY_SIGNER), game_pk))?; + let st_player = builder.priv_op(Operation::eq((&pod_points_lvl_2, "player"), "Alice"))?; + let st_level = builder.priv_op(Operation::eq((&pod_points_lvl_2, "level"), 2))?; + let st_points = builder.priv_op(Operation::eq((&pod_points_lvl_2, "points"), 5771))?; + let st_points_lvl_2 = builder.pub_op(Operation::custom( points_pred, - st_type, - st_signer, - st_player, - st_level, - st_points + [st_type, st_signer, st_player, st_level, st_points], ))?; let pod_alice_lvl_2_points = builder.prove(prover).unwrap(); println!("# pod_alice_lvl_2_points\n:{}", pod_alice_lvl_2_points); @@ -143,15 +138,16 @@ fn main() -> Result<(), Box> { let mut builder = MainPodBuilder::new(¶ms, vd_set); builder.add_recursive_pod(pod_alice_lvl_1_points); builder.add_recursive_pod(pod_alice_lvl_2_points); - let st_points_total = builder.priv_op(op!(sum_of, 3512 + 5771, 3512, 5771))?; - let st_gt_9000 = builder.priv_op(op!(gt, 3512 + 5771, 9000))?; - let _st_over_9000 = builder.pub_op(op!( - custom, + let st_points_total = builder.priv_op(Operation::sum_of(3512 + 5771, 3512, 5771))?; + let st_gt_9000 = builder.priv_op(Operation::gt(3512 + 5771, 9000))?; + let _st_over_9000 = builder.pub_op(Operation::custom( over_9000_pred, - st_points_lvl_1, - st_points_lvl_2, - st_points_total, - st_gt_9000 + [ + st_points_lvl_1, + st_points_lvl_2, + st_points_total, + st_gt_9000, + ], )); let pod_alice_over_9000 = builder.prove(prover).unwrap(); println!("# pod_alice_over_9000\n:{}", pod_alice_over_9000); diff --git a/src/backends/plonky2/mainpod/mod.rs b/src/backends/plonky2/mainpod/mod.rs index 0c30f1a..2a61889 100644 --- a/src/backends/plonky2/mainpod/mod.rs +++ b/src/backends/plonky2/mainpod/mod.rs @@ -750,7 +750,6 @@ pub mod tests { self, containers::Set, CustomPredicateRef, NativePredicate as NP, DEFAULT_VD_LIST, DEFAULT_VD_SET, }, - op, }; #[test] @@ -821,7 +820,10 @@ pub mod tests { let mut kyc_builder = frontend::MainPodBuilder::new(¶ms, &vd_set); kyc_builder.add_signed_pod(&gov_id); kyc_builder - .pub_op(op!(lt, (&gov_id, "dateOfBirth"), now_minus_18y)) + .pub_op(frontend::Operation::lt( + (&gov_id, "dateOfBirth"), + now_minus_18y, + )) .unwrap(); println!("{}", kyc_builder); @@ -951,11 +953,11 @@ pub mod tests { let mut pod_builder = MainPodBuilder::new(¶ms, &vd_set); - let st0 = pod_builder.priv_op(op!(new_entry, "score", 42))?; - let st1 = pod_builder.priv_op(op!(new_entry, "key", 42))?; - let st2 = pod_builder.priv_op(op!(eq, st1.clone(), st0.clone()))?; + let st0 = pod_builder.priv_op(frontend::Operation::new_entry("score", 42))?; + let st1 = pod_builder.priv_op(frontend::Operation::new_entry("key", 42))?; + let st2 = pod_builder.priv_op(frontend::Operation::eq(st1.clone(), st0.clone()))?; - let _st3 = pod_builder.priv_op(op!(custom, cpb_and.clone(), st0, st2))?; + let _st3 = pod_builder.priv_op(frontend::Operation::custom(cpb_and.clone(), [st0, st2]))?; let prover = MockProver {}; let pod = pod_builder.prove(&prover)?; @@ -976,14 +978,13 @@ pub mod tests { let mut builder = MainPodBuilder::new(¶ms, &DEFAULT_VD_SET); let set = [1, 2, 3].into_iter().map(|n| n.into()).collect(); let st = builder - .pub_op(op!( - new_entry, + .pub_op(frontend::Operation::new_entry( "entry", - Set::new(params.max_merkle_proofs_containers, set).unwrap() + Set::new(params.max_merkle_proofs_containers, set).unwrap(), )) .unwrap(); - builder.pub_op(op!(set_contains, st, 1))?; + builder.pub_op(frontend::Operation::set_contains(st, 1))?; let prover = Prover {}; let proof = builder.prove(&prover).unwrap(); diff --git a/src/examples/mod.rs b/src/examples/mod.rs index 29991b2..862399f 100644 --- a/src/examples/mod.rs +++ b/src/examples/mod.rs @@ -9,13 +9,14 @@ pub static MOCK_VD_SET: LazyLock = LazyLock::new(|| VDSet::new(6, &[]).un use crate::{ backends::plonky2::{primitives::ec::schnorr::SecretKey, signedpod::Signer}, - frontend::{MainPod, MainPodBuilder, PodRequest, Result, SignedPod, SignedPodBuilder}, + frontend::{ + MainPod, MainPodBuilder, Operation, PodRequest, Result, SignedPod, SignedPodBuilder, + }, lang::parse, middleware::{ containers::Set, hash_values, CustomPredicateRef, Params, PodSigner, PodType, Predicate, Statement, StatementArg, TypedValue, VDSet, Value, KEY_SIGNER, KEY_TYPE, }, - op, }; // ZuKYC @@ -55,19 +56,23 @@ pub fn zu_kyc_pod_builder( let mut kyc = MainPodBuilder::new(params, vd_set); kyc.add_signed_pod(gov_id); kyc.add_signed_pod(pay_stub); - kyc.pub_op(op!(set_not_contains, sanction_set, (gov_id, "idNumber")))?; - kyc.pub_op(op!(lt, (gov_id, "dateOfBirth"), now_minus_18y))?; - kyc.pub_op(op!( - eq, - (gov_id, "socialSecurityNumber"), - (pay_stub, "socialSecurityNumber") + kyc.pub_op(Operation::set_not_contains( + sanction_set, + (gov_id, "idNumber"), ))?; - kyc.pub_op(op!(eq, (pay_stub, "startDate"), now_minus_1y))?; - kyc.pub_op(op!(eq, (gov_id, "_signer"), gov_id.get("_signer").unwrap()))?; - kyc.pub_op(op!( - eq, + kyc.pub_op(Operation::lt((gov_id, "dateOfBirth"), now_minus_18y))?; + kyc.pub_op(Operation::eq( + (gov_id, "socialSecurityNumber"), + (pay_stub, "socialSecurityNumber"), + ))?; + kyc.pub_op(Operation::eq((pay_stub, "startDate"), now_minus_1y))?; + kyc.pub_op(Operation::eq( + (gov_id, "_signer"), + gov_id.get("_signer").unwrap(), + ))?; + kyc.pub_op(Operation::eq( (pay_stub, "_signer"), - pay_stub.get("_signer").unwrap() + pay_stub.get("_signer").unwrap(), ))?; Ok(kyc) @@ -146,19 +151,15 @@ impl EthDosHelper { let mut pod = MainPodBuilder::new(&self.params, &self.vd_set); pod.add_signed_pod(src_attestation); - let src_eq_src = pod.priv_op(op!(eq, self.src.clone(), self.src.clone()))?; - let distance_eq_zero = pod.priv_op(op!(eq, 0, 0))?; - let eth_dos_src_to_src_base = pod.priv_op(op!( - custom, + let src_eq_src = pod.priv_op(Operation::eq(self.src.clone(), self.src.clone()))?; + let distance_eq_zero = pod.priv_op(Operation::eq(0, 0))?; + let eth_dos_src_to_src_base = pod.priv_op(Operation::custom( self.eth_dos_base.clone(), - src_eq_src, - distance_eq_zero + [src_eq_src, distance_eq_zero], ))?; - let eth_dos_src_to_src = pod.priv_op(op!( - custom, + let eth_dos_src_to_src = pod.priv_op(Operation::custom( self.eth_dos.clone(), - eth_dos_src_to_src_base, - Statement::None + [eth_dos_src_to_src_base, Statement::None], ))?; // eth_dos src->dst dist=1 @@ -232,28 +233,24 @@ impl EthDosHelper { let attestation_is_signed_pod = int_attestation.get_statement(KEY_TYPE).unwrap(); let attestation_signed_by_int = int_attestation.get_statement(KEY_SIGNER).unwrap(); let int_attests_to_dst = int_attestation.get_statement("attestation").unwrap(); - let ethfriends_int_dst = pod.priv_op(op!( - custom, + let ethfriends_int_dst = pod.priv_op(Operation::custom( self.eth_friend.clone(), - attestation_is_signed_pod, - attestation_signed_by_int, - int_attests_to_dst + [ + attestation_is_signed_pod, + attestation_signed_by_int, + int_attests_to_dst, + ], ))?; // distance = n + 1 - let ethdos_sum = pod.priv_op(op!(sum_of, n + 1, n, 1))?; - let eth_dos_src_to_dst_ind = pod.priv_op(op!( - custom, + let ethdos_sum = pod.priv_op(Operation::sum_of(n + 1, n, 1))?; + let eth_dos_src_to_dst_ind = pod.priv_op(Operation::custom( self.eth_dos_ind.clone(), - eth_dos_int_to_dst, - ethdos_sum, - ethfriends_int_dst + [eth_dos_int_to_dst, ethdos_sum, ethfriends_int_dst], ))?; - let _eth_dos_src_dst = pod.pub_op(op!( - custom, + let _eth_dos_src_dst = pod.pub_op(Operation::custom( self.eth_dos.clone(), - Statement::None, - eth_dos_src_to_dst_ind + [Statement::None, eth_dos_src_to_dst_ind], ))?; Ok(()) @@ -303,49 +300,42 @@ pub fn great_boy_pod_builder( for good_boy_idx in 0..2 { // Type check - great_boy.pub_op(op!( - eq, + great_boy.pub_op(Operation::eq( (friend_pods[good_boy_idx], KEY_TYPE), - PodType::Signed as i64 + PodType::Signed as i64, ))?; for issuer_idx in 0..2 { // Type check - great_boy.pub_op(op!( - eq, + great_boy.pub_op(Operation::eq( (good_boy_pods[good_boy_idx * 2 + issuer_idx], KEY_TYPE), - PodType::Signed as i64 + PodType::Signed as i64, ))?; // Each good boy POD comes from a valid issuer - great_boy.pub_op(op!( - set_contains, + great_boy.pub_op(Operation::set_contains( good_boy_issuers, - (good_boy_pods[good_boy_idx * 2 + issuer_idx], KEY_SIGNER) + (good_boy_pods[good_boy_idx * 2 + issuer_idx], KEY_SIGNER), ))?; // Each good boy has 2 good boy pods - great_boy.pub_op(op!( - eq, + great_boy.pub_op(Operation::eq( (good_boy_pods[good_boy_idx * 2 + issuer_idx], "user"), - (friend_pods[good_boy_idx], KEY_SIGNER) + (friend_pods[good_boy_idx], KEY_SIGNER), ))?; } // The good boy PODs from each good boy have different issuers - great_boy.pub_op(op!( - ne, + great_boy.pub_op(Operation::ne( (good_boy_pods[good_boy_idx * 2], KEY_SIGNER), - (good_boy_pods[good_boy_idx * 2 + 1], KEY_SIGNER) + (good_boy_pods[good_boy_idx * 2 + 1], KEY_SIGNER), ))?; // Each good boy is receivers' friend - great_boy.pub_op(op!( - eq, + great_boy.pub_op(Operation::eq( (friend_pods[good_boy_idx], "friend"), - receiver.clone() + receiver.clone(), ))?; } // The two good boys are different - great_boy.pub_op(op!( - ne, + great_boy.pub_op(Operation::ne( (friend_pods[0], KEY_SIGNER), - (friend_pods[1], KEY_SIGNER) + (friend_pods[1], KEY_SIGNER), ))?; Ok(great_boy) @@ -449,29 +439,27 @@ pub fn tickets_pod_builder( // Create a main pod referencing this signed pod with some statements let mut builder = MainPodBuilder::new(params, vd_set); builder.add_signed_pod(signed_pod); - builder.pub_op(op!(eq, (signed_pod, "eventId"), expected_event_id))?; - builder.pub_op(op!(eq, (signed_pod, "isConsumed"), expect_consumed))?; - builder.pub_op(op!(eq, (signed_pod, "isRevoked"), false))?; - builder.pub_op(op!( - dict_not_contains, + builder.pub_op(Operation::eq((signed_pod, "eventId"), expected_event_id))?; + builder.pub_op(Operation::eq((signed_pod, "isConsumed"), expect_consumed))?; + builder.pub_op(Operation::eq((signed_pod, "isRevoked"), false))?; + builder.pub_op(Operation::dict_not_contains( blacklisted_email_set_value, - (signed_pod, "attendeeEmail") + (signed_pod, "attendeeEmail"), ))?; // This isn't the most fool-proof way to prove ownership (it requires // verifier to check pod ID on an anchored key to confirm statement wasn't // copied), but it's the simplest. let st_sk = builder.priv_literal(TICKET_OWNER_SECRET_KEY)?; - builder.pub_op(op!( - public_key_of, + builder.pub_op(Operation::public_key_of( (signed_pod, "attendeePublicKey"), - st_sk.clone() + st_sk.clone(), ))?; // Nullifier calculation is public, but based on the private sk. let external_nullifier = "external nullifier"; let nullifier = hash_values(&[TICKET_OWNER_SECRET_KEY.into(), external_nullifier.into()]); - builder.pub_op(op!(hash_of, nullifier, st_sk, external_nullifier))?; + builder.pub_op(Operation::hash_of(nullifier, st_sk, external_nullifier))?; Ok(builder) } diff --git a/src/frontend/custom.rs b/src/frontend/custom.rs index 2e8ba39..d83e0a1 100644 --- a/src/frontend/custom.rs +++ b/src/frontend/custom.rs @@ -237,9 +237,8 @@ mod tests { use crate::{ backends::plonky2::mock::mainpod::MockProver, examples::{custom::eth_dos_batch, MOCK_VD_SET}, - frontend::MainPodBuilder, + frontend::{MainPodBuilder, Operation}, middleware::{self, containers::Set, CustomPredicateRef, Params, PodType, DEFAULT_VD_SET}, - op, }; #[test] @@ -291,11 +290,11 @@ mod tests { let mut mp_builder = MainPodBuilder::new(¶ms, vd_set); // 2 > 1 - let s1 = mp_builder.priv_op(op!(new_entry, "s1_key", Value::from(2)))?; - let s2 = mp_builder.priv_op(op!(new_entry, "s2_key", Value::from(1)))?; + let s1 = mp_builder.priv_op(Operation::new_entry("s1_key", Value::from(2)))?; + let s2 = mp_builder.priv_op(Operation::new_entry("s2_key", Value::from(1)))?; // Adding a gt operation will produce a desugared lt operation - let desugared_gt = mp_builder.pub_op(op!(gt, s1, s2))?; + let desugared_gt = mp_builder.pub_op(Operation::gt(s1, s2))?; assert_eq!( desugared_gt.predicate(), Predicate::Native(NativePredicate::Lt) @@ -308,7 +307,7 @@ mod tests { // Check that our custom predicate matches the statement template // against the desugared gt statement (actually a lt statement) - mp_builder.pub_op(op!(custom, gt_custom_pred, desugared_gt))?; + mp_builder.pub_op(Operation::custom(gt_custom_pred, [desugared_gt]))?; // Check that the POD builds let prover = MockProver {}; @@ -340,14 +339,13 @@ mod tests { let mut mp_builder = MainPodBuilder::new(¶ms, vd_set); let set_values: HashSet = [1, 2, 3].iter().map(|i| Value::from(*i)).collect(); - let s1 = mp_builder.priv_op(op!( - new_entry, + let s1 = mp_builder.priv_op(Operation::new_entry( "s1_key", - Value::from(Set::new(params.max_depth_mt_containers, set_values)?) + Value::from(Set::new(params.max_depth_mt_containers, set_values)?), ))?; - let s2 = mp_builder.priv_op(op!(new_entry, "s2_key", Value::from(1)))?; + let s2 = mp_builder.priv_op(Operation::new_entry("s2_key", Value::from(1)))?; - let set_contains = mp_builder.pub_op(op!(set_contains, s1, s2))?; + let set_contains = mp_builder.pub_op(Operation::set_contains(s1, s2))?; assert_eq!( set_contains.predicate(), Predicate::Native(NativePredicate::Contains) @@ -358,7 +356,7 @@ mod tests { ); let set_contains_custom_pred = CustomPredicateRef::new(batch, 0); - mp_builder.pub_op(op!(custom, set_contains_custom_pred, set_contains))?; + mp_builder.pub_op(Operation::custom(set_contains_custom_pred, [set_contains]))?; let prover = MockProver {}; let proof = mp_builder.prove(&prover)?; diff --git a/src/frontend/mod.rs b/src/frontend/mod.rs index 0ace524..e9a61c6 100644 --- a/src/frontend/mod.rs +++ b/src/frontend/mod.rs @@ -726,84 +726,6 @@ impl MainPodCompiler { } } -// TODO fn fmt_signed_pod_builder -// TODO fn fmt_main_pod - -#[macro_use] -pub mod build_utils { - #[macro_export] - macro_rules! op_args { - ($($arg:expr),+) => {vec![$($crate::frontend::OperationArg::from($arg)),*]} - } - - #[macro_export] - macro_rules! op { - (new_entry, $key:expr, $value:expr) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::NewEntry), - $crate::op_args!(($key, $value)), $crate::middleware::OperationAux::None) }; - (copy, $($arg:expr),+) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::CopyStatement), - $crate::op_args!($($arg),*), $crate::middleware::OperationAux::None) }; - (eq, $($arg:expr),+) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::EqualFromEntries), - $crate::op_args!($($arg),*), $crate::middleware::OperationAux::None) }; - (ne, $($arg:expr),+) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::NotEqualFromEntries), - $crate::op_args!($($arg),*), $crate::middleware::OperationAux::None) }; - (gt, $($arg:expr),+) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::GtFromEntries), - $crate::op_args!($($arg),*), $crate::middleware::OperationAux::None) }; - (lt, $($arg:expr),+) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::LtFromEntries), - $crate::op_args!($($arg),*), $crate::middleware::OperationAux::None) }; - (transitive_eq, $($arg:expr),+) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::TransitiveEqualFromStatements), - $crate::op_args!($($arg),*), $crate::middleware::OperationAux::None) }; - (gt_to_ne, $($arg:expr),+) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::GtToNotEqual), - $crate::op_args!($($arg),*), $crate::middleware::OperationAux::None) }; - (lt_to_ne, $($arg:expr),+) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::LtToNotEqual), - $crate::op_args!($($arg),*), $crate::middleware::OperationAux::None) }; - (sum_of, $($arg:expr),+) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::SumOf), - $crate::op_args!($($arg),*), $crate::middleware::OperationAux::None) }; - (product_of, $($arg:expr),+) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::ProductOf), - $crate::op_args!($($arg),*), $crate::middleware::OperationAux::None) }; - (max_of, $($arg:expr),+) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::MaxOf), - $crate::op_args!($($arg),*), $crate::middleware::OperationAux::None) }; - (hash_of, $($arg:expr),+) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::HashOf), - $crate::op_args!($($arg),*), $crate::middleware::OperationAux::None) }; - (custom, $op:expr, $($arg:expr),*) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Custom($op), - $crate::op_args!($($arg),*), $crate::middleware::OperationAux::None) }; - (dict_contains, $dict:expr, $key:expr, $value:expr) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::DictContainsFromEntries), - $crate::op_args!($dict, $key, $value), $crate::middleware::OperationAux::None) }; - (dict_not_contains, $dict:expr, $key:expr) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::DictNotContainsFromEntries), - $crate::op_args!($dict, $key), $crate::middleware::OperationAux::None) }; - (set_contains, $set:expr, $value:expr) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::SetContainsFromEntries), - $crate::op_args!($set, $value), $crate::middleware::OperationAux::None) }; - (set_not_contains, $set:expr, $value:expr) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::SetNotContainsFromEntries), - $crate::op_args!($set, $value), $crate::middleware::OperationAux::None) }; - (array_contains, $array:expr, $index:expr, $value:expr) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::ArrayContainsFromEntries), - $crate::op_args!($array, $index, $value), $crate::middleware::OperationAux::None) }; - (hash_of, $hash:expr, $val1:expr, $val2:expr) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::HashOf), - $crate::op_args!($hash, $val1, $val2), $crate::middleware::OperationAux::None) }; - (public_key_of, $pk:expr, $sk:expr) => { $crate::frontend::Operation( - $crate::middleware::OperationType::Native($crate::middleware::NativeOperation::PublicKeyOf), - $crate::op_args!($pk, $sk), $crate::middleware::OperationAux::None) }; - } -} - #[cfg(test)] pub mod tests { @@ -1031,7 +953,7 @@ pub mod tests { let mut builder = MainPodBuilder::new(¶ms, vd_set); builder.add_signed_pod(&pod); - builder.pub_op(op!(gt, (&pod, "num"), 5)).unwrap(); + builder.pub_op(Operation::gt((&pod, "num"), 5)).unwrap(); let prover = MockProver {}; let false_pod = builder.prove(&prover).unwrap(); @@ -1062,7 +984,7 @@ pub mod tests { let mut builder = MainPodBuilder::new(¶ms, vd_set); builder.add_signed_pod(&pod); let st0 = pod.get_statement("dict").unwrap(); - let st1 = builder.op(true, op!(new_entry, "key", "a")).unwrap(); + let st1 = builder.op(true, Operation::new_entry("key", "a")).unwrap(); let st2 = builder.literal(false, Value::from(1)).unwrap(); builder @@ -1106,7 +1028,7 @@ pub mod tests { builder.add_signed_pod(&signed_pod); let st0 = signed_pod.get_statement("owner").unwrap(); let st1 = builder - .priv_op(op!(new_entry, "known_secret", Value::from(sk))) + .priv_op(Operation::new_entry("known_secret", Value::from(sk))) .unwrap(); builder .pub_op(Operation( @@ -1148,10 +1070,9 @@ pub mod tests { builder.add_signed_pod(&signed_pod); let st0 = signed_pod.get_statement("owner").unwrap(); let st1 = builder - .priv_op(op!( - new_entry, + .priv_op(Operation::new_entry( "known_secret", - Value::from(SecretKey(BigUint::from(123u32))) + Value::from(SecretKey(BigUint::from(123u32))), )) .unwrap(); assert!(builder diff --git a/src/frontend/operation.rs b/src/frontend/operation.rs index ed96a1b..e4fa3b5 100644 --- a/src/frontend/operation.rs +++ b/src/frontend/operation.rs @@ -180,18 +180,21 @@ impl Operation { op_impl_oa!(sum_of, SumOf, 3); op_impl_oa!(product_of, ProductOf, 3); op_impl_oa!(max_of, MaxOf, 3); + op_impl_oa!(hash_of, HashOf, 3); /// Creates a custom operation. /// /// `args` should contain the statements that are needed to prove the /// custom statement. It should have the same length as /// `cpr.predicate().statements()`. If `cpr` refers to an `or` predicate, /// then all but one of the statements should be `Statement::None`. - pub fn custom(cpr: CustomPredicateRef, args: Vec) -> Self { - Self(OperationType::Custom(cpr), args, OperationAux::None) + pub fn custom(cpr: CustomPredicateRef, args: impl IntoIterator) -> Self { + let op_args = args.into_iter().map(OperationArg::from).collect(); + Self(OperationType::Custom(cpr), op_args, OperationAux::None) } op_impl_oa!(dict_contains, DictContainsFromEntries, 3); op_impl_oa!(dict_not_contains, DictNotContainsFromEntries, 2); op_impl_oa!(set_contains, SetContainsFromEntries, 2); op_impl_oa!(set_not_contains, SetNotContainsFromEntries, 2); op_impl_oa!(array_contains, ArrayContainsFromEntries, 3); + op_impl_oa!(public_key_of, PublicKeyOf, 2); }