ed255/pod2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

remove op! macro (#378)

Browse source
This commit is contained in:
Daniel Gulotta 2025-08-01 09:52:06 -07:00 • committed by GitHub
parent 7f120f026d
commit fe8c4eceb3
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
6 changed files with 118 additions and 211 deletions
Download patch file Download diff file Expand all files Collapse all files

64
examples/main_pod_points.rs
View file

@ -15,10 +15,9 @@ use pod2::{
basetypes::DEFAULT_VD_SET, mainpod::Prover, mock::mainpod::MockProver, basetypes::DEFAULT_VD_SET, mainpod::Prover, mock::mainpod::MockProver,
primitives::ec::schnorr::SecretKey, signedpod::Signer, primitives::ec::schnorr::SecretKey, signedpod::Signer,
}, },
frontend::{MainPodBuilder, SignedPodBuilder}, frontend::{MainPodBuilder, Operation, SignedPodBuilder},
lang::parse, lang::parse,
middleware::{Params, PodProver, PodType, VDSet, Value, KEY_SIGNER, KEY_TYPE}, middleware::{Params, PodProver, PodType, VDSet, Value, KEY_SIGNER, KEY_TYPE},
op,
}; };
fn main() -> Result<(), Box<dyn std::error::Error>> { fn main() -> Result<(), Box<dyn std::error::Error>> {
@ -100,19 +99,17 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
// Build a pod to prove the statement `points("Alice", 1, 3512)` // Build a pod to prove the statement `points("Alice", 1, 3512)`
let mut builder = MainPodBuilder::new(&params, vd_set); let mut builder = MainPodBuilder::new(&params, vd_set);
builder.add_signed_pod(&pod_points_lvl_1); 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_type = builder.priv_op(Operation::eq(
let st_signer = builder.priv_op(op!(eq, (&pod_points_lvl_1, KEY_SIGNER), game_pk))?; (&pod_points_lvl_1, KEY_TYPE),
let st_player = builder.priv_op(op!(eq, (&pod_points_lvl_1, "player"), "Alice"))?; PodType::Signed,
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_signer = builder.priv_op(Operation::eq((&pod_points_lvl_1, KEY_SIGNER), game_pk))?;
let st_points_lvl_1 = builder.pub_op(op!( let st_player = builder.priv_op(Operation::eq((&pod_points_lvl_1, "player"), "Alice"))?;
custom, 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(), points_pred.clone(),
st_type, [st_type, st_signer, st_player, st_level, st_points],
st_signer,
st_player,
st_level,
st_points
))?; ))?;
let pod_alice_lvl_1_points = builder.prove(prover).unwrap(); let pod_alice_lvl_1_points = builder.prove(prover).unwrap();
println!("# pod_alice_lvl_1_points\n:{}", pod_alice_lvl_1_points); println!("# pod_alice_lvl_1_points\n:{}", pod_alice_lvl_1_points);
@ -121,19 +118,17 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
// Build a pod to prove the statement `points("Alice", 2, 5771)` // Build a pod to prove the statement `points("Alice", 2, 5771)`
let mut builder = MainPodBuilder::new(&params, vd_set); let mut builder = MainPodBuilder::new(&params, vd_set);
builder.add_signed_pod(&pod_points_lvl_2); 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_type = builder.priv_op(Operation::eq(
let st_signer = builder.priv_op(op!(eq, (&pod_points_lvl_2, KEY_SIGNER), game_pk))?; (&pod_points_lvl_2, KEY_TYPE),
let st_player = builder.priv_op(op!(eq, (&pod_points_lvl_2, "player"), "Alice"))?; PodType::Signed,
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_signer = builder.priv_op(Operation::eq((&pod_points_lvl_2, KEY_SIGNER), game_pk))?;
let st_points_lvl_2 = builder.pub_op(op!( let st_player = builder.priv_op(Operation::eq((&pod_points_lvl_2, "player"), "Alice"))?;
custom, 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, points_pred,
st_type, [st_type, st_signer, st_player, st_level, st_points],
st_signer,
st_player,
st_level,
st_points
))?; ))?;
let pod_alice_lvl_2_points = builder.prove(prover).unwrap(); let pod_alice_lvl_2_points = builder.prove(prover).unwrap();
println!("# pod_alice_lvl_2_points\n:{}", pod_alice_lvl_2_points); println!("# pod_alice_lvl_2_points\n:{}", pod_alice_lvl_2_points);
@ -143,15 +138,16 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut builder = MainPodBuilder::new(&params, vd_set); let mut builder = MainPodBuilder::new(&params, vd_set);
builder.add_recursive_pod(pod_alice_lvl_1_points); builder.add_recursive_pod(pod_alice_lvl_1_points);
builder.add_recursive_pod(pod_alice_lvl_2_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_points_total = builder.priv_op(Operation::sum_of(3512 + 5771, 3512, 5771))?;
let st_gt_9000 = builder.priv_op(op!(gt, 3512 + 5771, 9000))?; let st_gt_9000 = builder.priv_op(Operation::gt(3512 + 5771, 9000))?;
let _st_over_9000 = builder.pub_op(op!( let _st_over_9000 = builder.pub_op(Operation::custom(
custom,
over_9000_pred, over_9000_pred,
st_points_lvl_1, [
st_points_lvl_2, st_points_lvl_1,
st_points_total, st_points_lvl_2,
st_gt_9000 st_points_total,
st_gt_9000,
],
)); ));
let pod_alice_over_9000 = builder.prove(prover).unwrap(); let pod_alice_over_9000 = builder.prove(prover).unwrap();
println!("# pod_alice_over_9000\n:{}", pod_alice_over_9000); println!("# pod_alice_over_9000\n:{}", pod_alice_over_9000);

21
src/backends/plonky2/mainpod/mod.rs
View file

@ -750,7 +750,6 @@ pub mod tests {
self, containers::Set, CustomPredicateRef, NativePredicate as NP, DEFAULT_VD_LIST, self, containers::Set, CustomPredicateRef, NativePredicate as NP, DEFAULT_VD_LIST,
DEFAULT_VD_SET, DEFAULT_VD_SET,
}, },
op,
}; };
#[test] #[test]
@ -821,7 +820,10 @@ pub mod tests {
let mut kyc_builder = frontend::MainPodBuilder::new(&params, &vd_set); let mut kyc_builder = frontend::MainPodBuilder::new(&params, &vd_set);
kyc_builder.add_signed_pod(&gov_id); kyc_builder.add_signed_pod(&gov_id);
kyc_builder kyc_builder
.pub_op(op!(lt, (&gov_id, "dateOfBirth"), now_minus_18y)) .pub_op(frontend::Operation::lt(
(&gov_id, "dateOfBirth"),
now_minus_18y,
))
.unwrap(); .unwrap();
println!("{}", kyc_builder); println!("{}", kyc_builder);
@ -951,11 +953,11 @@ pub mod tests {
let mut pod_builder = MainPodBuilder::new(&params, &vd_set); let mut pod_builder = MainPodBuilder::new(&params, &vd_set);
let st0 = pod_builder.priv_op(op!(new_entry, "score", 42))?; let st0 = pod_builder.priv_op(frontend::Operation::new_entry("score", 42))?;
let st1 = pod_builder.priv_op(op!(new_entry, "key", 42))?; let st1 = pod_builder.priv_op(frontend::Operation::new_entry("key", 42))?;
let st2 = pod_builder.priv_op(op!(eq, st1.clone(), st0.clone()))?; 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 prover = MockProver {};
let pod = pod_builder.prove(&prover)?; let pod = pod_builder.prove(&prover)?;
@ -976,14 +978,13 @@ pub mod tests {
let mut builder = MainPodBuilder::new(&params, &DEFAULT_VD_SET); let mut builder = MainPodBuilder::new(&params, &DEFAULT_VD_SET);
let set = [1, 2, 3].into_iter().map(|n| n.into()).collect(); let set = [1, 2, 3].into_iter().map(|n| n.into()).collect();
let st = builder let st = builder
.pub_op(op!( .pub_op(frontend::Operation::new_entry(
new_entry,
"entry", "entry",
Set::new(params.max_merkle_proofs_containers, set).unwrap() Set::new(params.max_merkle_proofs_containers, set).unwrap(),
)) ))
.unwrap(); .unwrap();
builder.pub_op(op!(set_contains, st, 1))?; builder.pub_op(frontend::Operation::set_contains(st, 1))?;
let prover = Prover {}; let prover = Prover {};
let proof = builder.prove(&prover).unwrap(); let proof = builder.prove(&prover).unwrap();

126
src/examples/mod.rs
View file

@ -9,13 +9,14 @@ pub static MOCK_VD_SET: LazyLock<VDSet> = LazyLock::new(|| VDSet::new(6, &[]).un
use crate::{ use crate::{
backends::plonky2::{primitives::ec::schnorr::SecretKey, signedpod::Signer}, 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, lang::parse,
middleware::{ middleware::{
containers::Set, hash_values, CustomPredicateRef, Params, PodSigner, PodType, Predicate, containers::Set, hash_values, CustomPredicateRef, Params, PodSigner, PodType, Predicate,
Statement, StatementArg, TypedValue, VDSet, Value, KEY_SIGNER, KEY_TYPE, Statement, StatementArg, TypedValue, VDSet, Value, KEY_SIGNER, KEY_TYPE,
}, },
op,
}; };
// ZuKYC // ZuKYC
@ -55,19 +56,23 @@ pub fn zu_kyc_pod_builder(
let mut kyc = MainPodBuilder::new(params, vd_set); let mut kyc = MainPodBuilder::new(params, vd_set);
kyc.add_signed_pod(gov_id); kyc.add_signed_pod(gov_id);
kyc.add_signed_pod(pay_stub); kyc.add_signed_pod(pay_stub);
kyc.pub_op(op!(set_not_contains, sanction_set, (gov_id, "idNumber")))?; kyc.pub_op(Operation::set_not_contains(
kyc.pub_op(op!(lt, (gov_id, "dateOfBirth"), now_minus_18y))?; sanction_set,
kyc.pub_op(op!( (gov_id, "idNumber"),
eq,
(gov_id, "socialSecurityNumber"),
(pay_stub, "socialSecurityNumber")
))?; ))?;
kyc.pub_op(op!(eq, (pay_stub, "startDate"), now_minus_1y))?; kyc.pub_op(Operation::lt((gov_id, "dateOfBirth"), now_minus_18y))?;
kyc.pub_op(op!(eq, (gov_id, "_signer"), gov_id.get("_signer").unwrap()))?; kyc.pub_op(Operation::eq(
kyc.pub_op(op!( (gov_id, "socialSecurityNumber"),
eq, (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, "_signer"),
pay_stub.get("_signer").unwrap() pay_stub.get("_signer").unwrap(),
))?; ))?;
Ok(kyc) Ok(kyc)
@ -146,19 +151,15 @@ impl EthDosHelper {
let mut pod = MainPodBuilder::new(&self.params, &self.vd_set); let mut pod = MainPodBuilder::new(&self.params, &self.vd_set);
pod.add_signed_pod(src_attestation); pod.add_signed_pod(src_attestation);
let src_eq_src = pod.priv_op(op!(eq, self.src.clone(), self.src.clone()))?; let src_eq_src = pod.priv_op(Operation::eq(self.src.clone(), self.src.clone()))?;
let distance_eq_zero = pod.priv_op(op!(eq, 0, 0))?; let distance_eq_zero = pod.priv_op(Operation::eq(0, 0))?;
let eth_dos_src_to_src_base = pod.priv_op(op!( let eth_dos_src_to_src_base = pod.priv_op(Operation::custom(
custom,
self.eth_dos_base.clone(), self.eth_dos_base.clone(),
src_eq_src, [src_eq_src, distance_eq_zero],
distance_eq_zero
))?; ))?;
let eth_dos_src_to_src = pod.priv_op(op!( let eth_dos_src_to_src = pod.priv_op(Operation::custom(
custom,
self.eth_dos.clone(), self.eth_dos.clone(),
eth_dos_src_to_src_base, [eth_dos_src_to_src_base, Statement::None],
Statement::None
))?; ))?;
// eth_dos src->dst dist=1 // 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_is_signed_pod = int_attestation.get_statement(KEY_TYPE).unwrap();
let attestation_signed_by_int = int_attestation.get_statement(KEY_SIGNER).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 int_attests_to_dst = int_attestation.get_statement("attestation").unwrap();
let ethfriends_int_dst = pod.priv_op(op!( let ethfriends_int_dst = pod.priv_op(Operation::custom(
custom,
self.eth_friend.clone(), self.eth_friend.clone(),
attestation_is_signed_pod, [
attestation_signed_by_int, attestation_is_signed_pod,
int_attests_to_dst attestation_signed_by_int,
int_attests_to_dst,
],
))?; ))?;
// distance = n + 1 // distance = n + 1
let ethdos_sum = pod.priv_op(op!(sum_of, n + 1, n, 1))?; let ethdos_sum = pod.priv_op(Operation::sum_of(n + 1, n, 1))?;
let eth_dos_src_to_dst_ind = pod.priv_op(op!( let eth_dos_src_to_dst_ind = pod.priv_op(Operation::custom(
custom,
self.eth_dos_ind.clone(), self.eth_dos_ind.clone(),
eth_dos_int_to_dst, [eth_dos_int_to_dst, ethdos_sum, ethfriends_int_dst],
ethdos_sum,
ethfriends_int_dst
))?; ))?;
let _eth_dos_src_dst = pod.pub_op(op!( let _eth_dos_src_dst = pod.pub_op(Operation::custom(
custom,
self.eth_dos.clone(), self.eth_dos.clone(),
Statement::None, [Statement::None, eth_dos_src_to_dst_ind],
eth_dos_src_to_dst_ind
))?; ))?;
Ok(()) Ok(())
@ -303,49 +300,42 @@ pub fn great_boy_pod_builder(
for good_boy_idx in 0..2 { for good_boy_idx in 0..2 {
// Type check // Type check
great_boy.pub_op(op!( great_boy.pub_op(Operation::eq(
eq,
(friend_pods[good_boy_idx], KEY_TYPE), (friend_pods[good_boy_idx], KEY_TYPE),
PodType::Signed as i64 PodType::Signed as i64,
))?; ))?;
for issuer_idx in 0..2 { for issuer_idx in 0..2 {
// Type check // Type check
great_boy.pub_op(op!( great_boy.pub_op(Operation::eq(
eq,
(good_boy_pods[good_boy_idx * 2 + issuer_idx], KEY_TYPE), (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 // Each good boy POD comes from a valid issuer
great_boy.pub_op(op!( great_boy.pub_op(Operation::set_contains(
set_contains,
good_boy_issuers, 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 // Each good boy has 2 good boy pods
great_boy.pub_op(op!( great_boy.pub_op(Operation::eq(
eq,
(good_boy_pods[good_boy_idx * 2 + issuer_idx], "user"), (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 // The good boy PODs from each good boy have different issuers
great_boy.pub_op(op!( great_boy.pub_op(Operation::ne(
ne,
(good_boy_pods[good_boy_idx * 2], KEY_SIGNER), (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 // Each good boy is receivers' friend
great_boy.pub_op(op!( great_boy.pub_op(Operation::eq(
eq,
(friend_pods[good_boy_idx], "friend"), (friend_pods[good_boy_idx], "friend"),
receiver.clone() receiver.clone(),
))?; ))?;
} }
// The two good boys are different // The two good boys are different
great_boy.pub_op(op!( great_boy.pub_op(Operation::ne(
ne,
(friend_pods[0], KEY_SIGNER), (friend_pods[0], KEY_SIGNER),
(friend_pods[1], KEY_SIGNER) (friend_pods[1], KEY_SIGNER),
))?; ))?;
Ok(great_boy) Ok(great_boy)
@ -449,29 +439,27 @@ pub fn tickets_pod_builder(
// Create a main pod referencing this signed pod with some statements // Create a main pod referencing this signed pod with some statements
let mut builder = MainPodBuilder::new(params, vd_set); let mut builder = MainPodBuilder::new(params, vd_set);
builder.add_signed_pod(signed_pod); builder.add_signed_pod(signed_pod);
builder.pub_op(op!(eq, (signed_pod, "eventId"), expected_event_id))?; builder.pub_op(Operation::eq((signed_pod, "eventId"), expected_event_id))?;
builder.pub_op(op!(eq, (signed_pod, "isConsumed"), expect_consumed))?; builder.pub_op(Operation::eq((signed_pod, "isConsumed"), expect_consumed))?;
builder.pub_op(op!(eq, (signed_pod, "isRevoked"), false))?; builder.pub_op(Operation::eq((signed_pod, "isRevoked"), false))?;
builder.pub_op(op!( builder.pub_op(Operation::dict_not_contains(
dict_not_contains,
blacklisted_email_set_value, blacklisted_email_set_value,
(signed_pod, "attendeeEmail") (signed_pod, "attendeeEmail"),
))?; ))?;
// This isn't the most fool-proof way to prove ownership (it requires // 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 // verifier to check pod ID on an anchored key to confirm statement wasn't
// copied), but it's the simplest. // copied), but it's the simplest.
let st_sk = builder.priv_literal(TICKET_OWNER_SECRET_KEY)?; let st_sk = builder.priv_literal(TICKET_OWNER_SECRET_KEY)?;
builder.pub_op(op!( builder.pub_op(Operation::public_key_of(
public_key_of,
(signed_pod, "attendeePublicKey"), (signed_pod, "attendeePublicKey"),
st_sk.clone() st_sk.clone(),
))?; ))?;
// Nullifier calculation is public, but based on the private sk. // Nullifier calculation is public, but based on the private sk.
let external_nullifier = "external nullifier"; let external_nullifier = "external nullifier";
let nullifier = hash_values(&[TICKET_OWNER_SECRET_KEY.into(), external_nullifier.into()]); 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) Ok(builder)
} }

22
src/frontend/custom.rs
View file

@ -237,9 +237,8 @@ mod tests {
use crate::{ use crate::{
backends::plonky2::mock::mainpod::MockProver, backends::plonky2::mock::mainpod::MockProver,
examples::{custom::eth_dos_batch, MOCK_VD_SET}, examples::{custom::eth_dos_batch, MOCK_VD_SET},
frontend::MainPodBuilder, frontend::{MainPodBuilder, Operation},
middleware::{self, containers::Set, CustomPredicateRef, Params, PodType, DEFAULT_VD_SET}, middleware::{self, containers::Set, CustomPredicateRef, Params, PodType, DEFAULT_VD_SET},
op,
}; };
#[test] #[test]
@ -291,11 +290,11 @@ mod tests {
let mut mp_builder = MainPodBuilder::new(&params, vd_set); let mut mp_builder = MainPodBuilder::new(&params, vd_set);
// 2 > 1 // 2 > 1
let s1 = mp_builder.priv_op(op!(new_entry, "s1_key", Value::from(2)))?; let s1 = mp_builder.priv_op(Operation::new_entry("s1_key", Value::from(2)))?;
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)))?;
// Adding a gt operation will produce a desugared lt operation // 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!( assert_eq!(
desugared_gt.predicate(), desugared_gt.predicate(),
Predicate::Native(NativePredicate::Lt) Predicate::Native(NativePredicate::Lt)
@ -308,7 +307,7 @@ mod tests {
// Check that our custom predicate matches the statement template // Check that our custom predicate matches the statement template
// against the desugared gt statement (actually a lt statement) // 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 // Check that the POD builds
let prover = MockProver {}; let prover = MockProver {};
@ -340,14 +339,13 @@ mod tests {
let mut mp_builder = MainPodBuilder::new(&params, vd_set); let mut mp_builder = MainPodBuilder::new(&params, vd_set);
let set_values: HashSet<Value> = [1, 2, 3].iter().map(|i| Value::from(*i)).collect(); let set_values: HashSet<Value> = [1, 2, 3].iter().map(|i| Value::from(*i)).collect();
let s1 = mp_builder.priv_op(op!( let s1 = mp_builder.priv_op(Operation::new_entry(
new_entry,
"s1_key", "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!( assert_eq!(
set_contains.predicate(), set_contains.predicate(),
Predicate::Native(NativePredicate::Contains) Predicate::Native(NativePredicate::Contains)
@ -358,7 +356,7 @@ mod tests {
); );
let set_contains_custom_pred = CustomPredicateRef::new(batch, 0); 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 prover = MockProver {};
let proof = mp_builder.prove(&prover)?; let proof = mp_builder.prove(&prover)?;

89
src/frontend/mod.rs
View file

@ -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)] #[cfg(test)]
pub mod tests { pub mod tests {
@ -1031,7 +953,7 @@ pub mod tests {
let mut builder = MainPodBuilder::new(&params, vd_set); let mut builder = MainPodBuilder::new(&params, vd_set);
builder.add_signed_pod(&pod); 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 prover = MockProver {};
let false_pod = builder.prove(&prover).unwrap(); let false_pod = builder.prove(&prover).unwrap();
@ -1062,7 +984,7 @@ pub mod tests {
let mut builder = MainPodBuilder::new(&params, vd_set); let mut builder = MainPodBuilder::new(&params, vd_set);
builder.add_signed_pod(&pod); builder.add_signed_pod(&pod);
let st0 = pod.get_statement("dict").unwrap(); 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(); let st2 = builder.literal(false, Value::from(1)).unwrap();
builder builder
@ -1106,7 +1028,7 @@ pub mod tests {
builder.add_signed_pod(&signed_pod); builder.add_signed_pod(&signed_pod);
let st0 = signed_pod.get_statement("owner").unwrap(); let st0 = signed_pod.get_statement("owner").unwrap();
let st1 = builder let st1 = builder
.priv_op(op!(new_entry, "known_secret", Value::from(sk))) .priv_op(Operation::new_entry("known_secret", Value::from(sk)))
.unwrap(); .unwrap();
builder builder
.pub_op(Operation( .pub_op(Operation(
@ -1148,10 +1070,9 @@ pub mod tests {
builder.add_signed_pod(&signed_pod); builder.add_signed_pod(&signed_pod);
let st0 = signed_pod.get_statement("owner").unwrap(); let st0 = signed_pod.get_statement("owner").unwrap();
let st1 = builder let st1 = builder
.priv_op(op!( .priv_op(Operation::new_entry(
new_entry,
"known_secret", "known_secret",
Value::from(SecretKey(BigUint::from(123u32))) Value::from(SecretKey(BigUint::from(123u32))),
)) ))
.unwrap(); .unwrap();
assert!(builder assert!(builder

7
src/frontend/operation.rs
View file

@ -180,18 +180,21 @@ impl Operation {
op_impl_oa!(sum_of, SumOf, 3); op_impl_oa!(sum_of, SumOf, 3);
op_impl_oa!(product_of, ProductOf, 3); op_impl_oa!(product_of, ProductOf, 3);
op_impl_oa!(max_of, MaxOf, 3); op_impl_oa!(max_of, MaxOf, 3);
op_impl_oa!(hash_of, HashOf, 3);
/// Creates a custom operation. /// Creates a custom operation.
/// ///
/// `args` should contain the statements that are needed to prove the /// `args` should contain the statements that are needed to prove the
/// custom statement. It should have the same length as /// custom statement. It should have the same length as
/// `cpr.predicate().statements()`. If `cpr` refers to an `or` predicate, /// `cpr.predicate().statements()`. If `cpr` refers to an `or` predicate,
/// then all but one of the statements should be `Statement::None`. /// then all but one of the statements should be `Statement::None`.
pub fn custom(cpr: CustomPredicateRef, args: Vec<OperationArg>) -> Self { pub fn custom(cpr: CustomPredicateRef, args: impl IntoIterator<Item = Statement>) -> Self {
Self(OperationType::Custom(cpr), args, OperationAux::None) 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_contains, DictContainsFromEntries, 3);
op_impl_oa!(dict_not_contains, DictNotContainsFromEntries, 2); op_impl_oa!(dict_not_contains, DictNotContainsFromEntries, 2);
op_impl_oa!(set_contains, SetContainsFromEntries, 2); op_impl_oa!(set_contains, SetContainsFromEntries, 2);
op_impl_oa!(set_not_contains, SetNotContainsFromEntries, 2); op_impl_oa!(set_not_contains, SetNotContainsFromEntries, 2);
op_impl_oa!(array_contains, ArrayContainsFromEntries, 3); op_impl_oa!(array_contains, ArrayContainsFromEntries, 3);
op_impl_oa!(public_key_of, PublicKeyOf, 2);
} }