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

58
examples/main_pod_points.rs
View file

@ -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<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)`
let mut builder = MainPodBuilder::new(&params, 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<dyn std::error::Error>> {
// Build a pod to prove the statement `points("Alice", 2, 5771)`
let mut builder = MainPodBuilder::new(&params, 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<dyn std::error::Error>> {
let mut builder = MainPodBuilder::new(&params, 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_gt_9000,
],
));
let pod_alice_over_9000 = builder.prove(prover).unwrap();
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,
DEFAULT_VD_SET,
},
op,
};
#[test]
@ -821,7 +820,10 @@ pub mod tests {
let mut kyc_builder = frontend::MainPodBuilder::new(&params, &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(&params, &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(&params, &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();

122
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::{
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
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)
}

22
src/frontend/custom.rs
View file

@ -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(&params, 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(&params, vd_set);
let set_values: HashSet<Value> = [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)?;

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)]
pub mod tests {
@ -1031,7 +953,7 @@ pub mod tests {
let mut builder = MainPodBuilder::new(&params, 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(&params, 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

7
src/frontend/operation.rs
View file

@ -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<OperationArg>) -> Self {
Self(OperationType::Custom(cpr), args, OperationAux::None)
pub fn custom(cpr: CustomPredicateRef, args: impl IntoIterator<Item = Statement>) -> 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);
}