1use crate::proof_system::{structs::VerifyingKey, verifier::Verifier};
9use ark_ec::{
10 pairing::Pairing,
11 short_weierstrass::{Affine, SWCurveConfig as SWParam},
12 twisted_edwards::TECurveConfig as TEParam,
13};
14use ark_ff::{BigInteger, PrimeField};
15use ark_std::{format, string::ToString, vec, vec::Vec};
16use jf_relation::{
17 gadgets::{
18 ecc::{MultiScalarMultiplicationCircuit, PointVariable, SWToTEConParam, TEPoint},
19 ultraplonk::mod_arith::{FpElem, FpElemVar},
20 },
21 Circuit, CircuitError,
22 CircuitError::ParameterError,
23 PlonkCircuit, Variable,
24};
25use jf_rescue::RescueParameter;
26
27mod gadgets;
28mod poly;
29mod structs;
30
31use gadgets::*;
32pub use structs::*;
33
34#[derive(Debug, Clone, Eq, PartialEq)]
35pub struct VerifyingKeyVar<E: Pairing> {
37 pub(crate) sigma_comms: Vec<PointVariable>,
39 pub(crate) selector_comms: Vec<PointVariable>,
41 is_merged: bool,
43
44 domain_size: usize,
46
47 num_inputs: usize,
49
50 k: Vec<E::ScalarField>,
53}
54
55impl<E: Pairing> VerifyingKeyVar<E> {
56 pub fn new<F, P>(
58 circuit: &mut PlonkCircuit<F>,
59 verify_key: &VerifyingKey<E>,
60 ) -> Result<Self, CircuitError>
61 where
62 E: Pairing<BaseField = F, G1Affine = Affine<P>>,
63 F: PrimeField + SWToTEConParam,
64 P: SWParam<BaseField = F>,
65 {
66 let sigma_comms = verify_key
67 .sigma_comms
68 .iter()
69 .map(|comm| circuit.create_point_variable(TEPoint::from(comm.0)))
70 .collect::<Result<Vec<_>, CircuitError>>()?;
71 let selector_comms = verify_key
72 .selector_comms
73 .iter()
74 .map(|comm| circuit.create_point_variable(TEPoint::from(comm.0)))
75 .collect::<Result<Vec<_>, CircuitError>>()?;
76 Ok(Self {
77 sigma_comms,
78 selector_comms,
79 is_merged: verify_key.is_merged,
80 domain_size: verify_key.domain_size,
81 num_inputs: verify_key.num_inputs,
82 k: verify_key.k.clone(),
83 })
84 }
85
86 pub fn to_vec(&self) -> Vec<Variable> {
88 let mut res = vec![];
89 for sigma_comm in self.sigma_comms.iter() {
90 res.push(sigma_comm.get_x());
91 res.push(sigma_comm.get_y());
92 }
93 for selector_comm in self.selector_comms.iter() {
94 res.push(selector_comm.get_x());
95 res.push(selector_comm.get_y());
96 }
97 res
98 }
99
100 pub(crate) fn merge<F, P>(
102 &self,
103 circuit: &mut PlonkCircuit<F>,
104 other: &Self,
105 ) -> Result<Self, CircuitError>
106 where
107 F: PrimeField,
108 P: TEParam<BaseField = F>,
109 {
110 if self.is_merged || other.is_merged {
111 return Err(ParameterError(
112 "cannot merge a merged key again".to_string(),
113 ));
114 }
115 if self.domain_size != other.domain_size {
116 return Err(ParameterError(
117 "cannot merge a verifying key with different domain size".to_string(),
118 ));
119 }
120 if self.num_inputs != other.num_inputs {
121 return Err(ParameterError(
122 "cannot merge a verifying key with different public input length".to_string(),
123 ));
124 }
125 let sigma_comms = self
126 .sigma_comms
127 .iter()
128 .zip(other.sigma_comms.iter())
129 .map(|(com1, com2)| circuit.ecc_add::<P>(com1, com2))
130 .collect::<Result<Vec<_>, CircuitError>>()?;
131 let selector_comms = self
132 .selector_comms
133 .iter()
134 .zip(other.selector_comms.iter())
135 .map(|(com1, com2)| circuit.ecc_add::<P>(com1, com2))
136 .collect::<Result<Vec<_>, CircuitError>>()?;
137 Ok(Self {
138 sigma_comms,
139 selector_comms,
140 is_merged: true,
141 domain_size: self.domain_size,
142 num_inputs: self.num_inputs + other.num_inputs,
143 k: self.k.clone(),
144 })
145 }
146
147 pub fn partial_verify_circuit<F, P>(
152 circuit: &mut PlonkCircuit<F>,
153 beta_g: &TEPoint<F>,
154 generator_g: &TEPoint<F>,
155 merged_vks: &[Self],
156 shared_public_input_vars: &[FpElemVar<F>],
157 batch_proof: &BatchProofVar<F>,
158 blinding_factor: Variable,
159 ) -> Result<(PointVariable, PointVariable), CircuitError>
160 where
161 E: Pairing<BaseField = F, G1Affine = Affine<P>>,
162 F: RescueParameter + SWToTEConParam,
163 P: SWParam<BaseField = F> + TEParam,
164 {
165 if merged_vks.is_empty() {
166 return Err(ParameterError("empty merged verification keys".to_string()));
167 }
168 if merged_vks.len() != batch_proof.len() {
169 return Err(ParameterError(format!(
170 "the number of verification keys {} is different from the number of instances {}.",
171 merged_vks.len(),
172 batch_proof.len()
173 )));
174 }
175
176 let domain_size = merged_vks[0].domain_size;
177 for (i, vk) in merged_vks.iter().skip(1).enumerate() {
178 if vk.domain_size != domain_size {
179 return Err(ParameterError(format!(
180 "the {}-th verification key's domain size {} is different from {}.",
181 i, vk.domain_size, domain_size
182 )));
183 }
184 }
185
186 let range_bit_len = circuit.range_bit_len()?;
187 let m2 = (<E::ScalarField as PrimeField>::MODULUS_BIT_SIZE as usize + 1) >> 1;
188 let m = (m2 - 1) / range_bit_len * range_bit_len + range_bit_len;
190
191 let two_power_m = Some(E::BaseField::from(2u8).pow([m as u64]));
193
194 let fr_modulus_bits = <E::ScalarField as PrimeField>::MODULUS.to_bytes_le();
195 let modulus_in_f = F::from_le_bytes_mod_order(&fr_modulus_bits);
196 let modulus_fp_elem = FpElem::new(&modulus_in_f, m, two_power_m)?;
197
198 let non_native_field_info = NonNativeFieldInfo::<F> {
199 m,
200 two_power_m,
201 modulus_in_f,
202 modulus_fp_elem,
203 };
204
205 let verifier = Verifier::<E>::new(domain_size)?;
206 let domain = verifier.domain;
207
208 let shared_public_input_vars =
210 [shared_public_input_vars, shared_public_input_vars].concat();
211 let public_inputs = vec![&shared_public_input_vars[..]; merged_vks.len()];
212 let merged_vks_ref: Vec<&VerifyingKeyVar<E>> = merged_vks.iter().collect();
213
214 let pcs_info_var = prepare_pcs_info_var(
216 circuit,
217 &merged_vks_ref,
218 &public_inputs,
219 batch_proof,
220 &None,
221 domain,
222 non_native_field_info,
223 )?;
224
225 let generator_g_var = circuit.create_constant_point_variable(*generator_g)?;
230 let bases = [
231 pcs_info_var.opening_proof,
232 pcs_info_var.shifted_opening_proof,
233 generator_g_var,
234 ];
235 let u_var = pcs_info_var.u.convert_to_var(circuit)?;
236 let scalars = [circuit.one(), u_var, blinding_factor];
237
238 let inner1 = MultiScalarMultiplicationCircuit::<_, P>::msm(circuit, &bases, &scalars)?;
239
240 let mut scalars_and_bases = pcs_info_var.comm_scalars_and_bases;
247 scalars_and_bases.scalars.push(pcs_info_var.eval_point);
248 scalars_and_bases.bases.push(pcs_info_var.opening_proof);
249
250 let tmp = circuit.mod_mul(
251 &pcs_info_var.next_eval_point,
252 &pcs_info_var.u,
253 &modulus_fp_elem,
254 )?;
255 scalars_and_bases.scalars.push(tmp);
256 scalars_and_bases
257 .bases
258 .push(pcs_info_var.shifted_opening_proof);
259
260 let generator_g_inv_var = circuit.create_constant_point_variable(generator_g.inverse())?;
261 scalars_and_bases.scalars.push(pcs_info_var.eval);
262 scalars_and_bases.bases.push(generator_g_inv_var);
263
264 let mut scalars = scalars_and_bases
265 .scalars
266 .iter()
267 .map(|x| x.convert_to_var(circuit))
268 .collect::<Result<Vec<_>, _>>()?;
269 scalars.push(blinding_factor);
270
271 let mut bases = scalars_and_bases.bases;
272 let beta_g = circuit.create_constant_point_variable(*beta_g)?;
273 bases.push(beta_g);
274 let inner2 = MultiScalarMultiplicationCircuit::<_, P>::msm(circuit, &bases, &scalars)?;
275
276 Ok((inner1, inner2))
277 }
278}
279
280pub trait BatchableCircuit<F> {
282 fn aggregate_verify_keys<E, P>(
284 &mut self,
285 vk_type_a_vars: &[VerifyingKeyVar<E>],
286 vk_type_b_vars: &[VerifyingKeyVar<E>],
287 ) -> Result<Vec<VerifyingKeyVar<E>>, CircuitError>
288 where
289 E: Pairing,
290 P: TEParam<BaseField = F>;
291}
292
293impl<F> BatchableCircuit<F> for PlonkCircuit<F>
295where
296 F: PrimeField,
297{
298 fn aggregate_verify_keys<E, P>(
299 &mut self,
300 vk_type_a_vars: &[VerifyingKeyVar<E>],
301 vk_type_b_vars: &[VerifyingKeyVar<E>],
302 ) -> Result<Vec<VerifyingKeyVar<E>>, CircuitError>
303 where
304 E: Pairing,
305 P: TEParam<BaseField = F>,
306 {
307 if vk_type_a_vars.len() != vk_type_b_vars.len() {
308 return Err(ParameterError(format!(
309 "the number of type A verification key variables {} is different from the number of type B verification key variables {}.",
310 vk_type_a_vars.len(),
311 vk_type_b_vars.len())
312 ));
313 }
314 vk_type_a_vars
315 .iter()
316 .zip(vk_type_b_vars.iter())
317 .map(|(vk_b, vk_d)| vk_b.merge::<F, P>(self, vk_d))
318 .collect::<Result<Vec<_>, CircuitError>>()
319 }
320}
321
322#[cfg(test)]
323mod test {
324 use super::*;
325 use crate::{
326 proof_system::{
327 batch_arg::{new_mergeable_circuit_for_test, BatchArgument},
328 structs::BatchProof,
329 PlonkKzgSnark, UniversalSNARK,
330 },
331 transcript::{PlonkTranscript, RescueTranscript},
332 };
333 use ark_bls12_377::{g1::Config as Param377, Bls12_377, Fq as Fq377, Fr as Fr377};
334 use ark_ec::{short_weierstrass::SWCurveConfig, twisted_edwards::TECurveConfig, CurveGroup};
335 use ark_std::{vec, UniformRand};
336 use jf_relation::{
337 gadgets::test_utils::test_variable_independence_for_circuit, MergeableCircuitType,
338 };
339 use jf_utils::{field_switching, test_rng};
340 use rstest::rstest;
341
342 const RANGE_BIT_LEN_FOR_TEST: usize = 16;
343
344 #[test]
345 fn test_aggregate_vks() -> Result<(), CircuitError> {
346 test_aggregate_vks_helper::<Bls12_377, Fq377, _, Param377>()
347 }
348
349 fn test_aggregate_vks_helper<E, F, P, Q>() -> Result<(), CircuitError>
350 where
351 E: Pairing<BaseField = F, G1Affine = Affine<P>>,
352 F: PrimeField + RescueParameter + SWToTEConParam,
353 P: SWParam<BaseField = F>,
354 Q: TEParam<BaseField = F>,
355 {
356 let rng = &mut test_rng();
358 let n = 32;
359 let max_degree = n + 2;
360 let srs = PlonkKzgSnark::<E>::universal_setup_for_testing(max_degree, rng)?;
361
362 let mut vks_type_a = vec![];
364 let mut vks_type_b = vec![];
365 let shared_public_input = E::ScalarField::rand(rng);
366 for i in 0..5 {
367 let circuit = new_mergeable_circuit_for_test::<E>(
368 shared_public_input,
369 i,
370 MergeableCircuitType::TypeA,
371 )?;
372 let instance =
373 BatchArgument::setup_instance(&srs, circuit, MergeableCircuitType::TypeA)?;
374 vks_type_a.push(instance.verify_key_ref().clone());
375
376 let circuit = new_mergeable_circuit_for_test::<E>(
377 shared_public_input,
378 i,
379 MergeableCircuitType::TypeB,
380 )?;
381 let instance =
382 BatchArgument::setup_instance(&srs, circuit, MergeableCircuitType::TypeB)?;
383 vks_type_b.push(instance.verify_key_ref().clone());
384 }
385 let vks_type_a_ref: Vec<&VerifyingKey<E>> = vks_type_a.iter().collect();
387 let vks_type_b_ref: Vec<&VerifyingKey<E>> = vks_type_b.iter().collect();
388 let merged_vks = BatchArgument::aggregate_verify_keys(&vks_type_a_ref, &vks_type_b_ref)?;
389
390 let mut circuit: PlonkCircuit<F> = PlonkCircuit::new_ultra_plonk(RANGE_BIT_LEN_FOR_TEST);
392 let vk_type_a_vars = vks_type_a
393 .iter()
394 .map(|vk| VerifyingKeyVar::new(&mut circuit, vk))
395 .collect::<Result<Vec<_>, CircuitError>>()?;
396 for (vk_var, vk) in vk_type_a_vars.iter().zip(vks_type_a.iter()) {
397 check_vk_equality(&circuit, vk_var, vk);
398 }
399
400 let vk_type_b_vars = vks_type_b
401 .iter()
402 .map(|vk| VerifyingKeyVar::new(&mut circuit, vk))
403 .collect::<Result<Vec<_>, CircuitError>>()?;
404 for (vk_var, vk) in vk_type_b_vars.iter().zip(vks_type_b.iter()) {
405 check_vk_equality(&circuit, vk_var, vk);
406 }
407
408 let merged_vk_vars =
409 circuit.aggregate_verify_keys::<E, Q>(&vk_type_a_vars, &vk_type_b_vars)?;
410 for (vk_var, vk) in merged_vk_vars.iter().zip(merged_vks.iter()) {
411 check_vk_equality(&circuit, vk_var, vk);
412 }
413
414 assert!(circuit.check_circuit_satisfiability(&[]).is_ok());
415
416 let tmp = circuit.witness(merged_vk_vars[0].sigma_comms[0].get_x())?;
419 *circuit.witness_mut(merged_vk_vars[0].sigma_comms[0].get_x()) = F::from(0u8);
420 assert!(circuit.check_circuit_satisfiability(&[]).is_err());
421 *circuit.witness_mut(merged_vk_vars[0].sigma_comms[0].get_x()) = tmp;
422
423 assert!(circuit
425 .aggregate_verify_keys::<E, Q>(&vk_type_a_vars[1..], &vk_type_b_vars)
426 .is_err());
427
428 let mut bad_vk_vars = vk_type_a_vars.clone();
430 bad_vk_vars[0].is_merged = true;
431 assert!(circuit
432 .aggregate_verify_keys::<E, Q>(&bad_vk_vars, &vk_type_b_vars)
433 .is_err());
434
435 Ok(())
436 }
437
438 fn check_vk_equality<E, F, P>(
439 circuit: &PlonkCircuit<F>,
440 vk_var: &VerifyingKeyVar<E>,
441 vk: &VerifyingKey<E>,
442 ) where
443 E: Pairing<BaseField = F, G1Affine = Affine<P>>,
444 F: PrimeField + SWToTEConParam,
445 P: SWParam<BaseField = F>,
446 {
447 for (comm_var, comm) in vk_var.sigma_comms.iter().zip(vk.sigma_comms.iter()) {
448 let expected_comm = TEPoint::from(comm.0);
449 assert_eq!(circuit.point_witness(comm_var).unwrap(), expected_comm);
450 }
451 for (comm_var, comm) in vk_var.selector_comms.iter().zip(vk.selector_comms.iter()) {
452 let expected_comm = TEPoint::from(comm.0);
453 assert_eq!(circuit.point_witness(comm_var).unwrap(), expected_comm);
454 }
455 assert_eq!(vk_var.is_merged, vk.is_merged);
456 }
457
458 #[rstest]
459 fn test_partial_verification_circuit(
460 #[values(8, 9, 10, 11)] log_circuit_size: usize,
461 ) -> Result<(), CircuitError> {
462 let rng = &mut test_rng();
463
464 let n = 1 << log_circuit_size;
470 let max_degree = n + 2;
471 let srs = PlonkKzgSnark::<Bls12_377>::universal_setup_for_testing(max_degree, rng)?;
472
473 let shared_public_input = Fr377::rand(rng);
475 let mut instances_type_a = vec![];
476 let mut instances_type_b = vec![];
477 for i in 32..50 {
478 let circuit = new_mergeable_circuit_for_test::<Bls12_377>(
479 shared_public_input,
480 i,
481 MergeableCircuitType::TypeA,
482 )?;
483 let instance =
484 BatchArgument::setup_instance(&srs, circuit, MergeableCircuitType::TypeA)?;
485 instances_type_a.push(instance);
486
487 let circuit = new_mergeable_circuit_for_test::<Bls12_377>(
488 shared_public_input,
489 i,
490 MergeableCircuitType::TypeB,
491 )?;
492 let instance =
493 BatchArgument::setup_instance(&srs, circuit, MergeableCircuitType::TypeB)?;
494 instances_type_b.push(instance);
495 }
496 let batch_proof = BatchArgument::batch_prove::<_, RescueTranscript<Fq377>>(
498 rng,
499 &instances_type_a,
500 &instances_type_b,
501 )?;
502
503 let vks_type_a: Vec<&VerifyingKey<Bls12_377>> = instances_type_a
505 .iter()
506 .map(|pred| pred.verify_key_ref())
507 .collect();
508 let vks_type_b: Vec<&VerifyingKey<Bls12_377>> = instances_type_b
509 .iter()
510 .map(|pred| pred.verify_key_ref())
511 .collect();
512 let merged_vks = BatchArgument::aggregate_verify_keys(&vks_type_a, &vks_type_b)?;
513 assert!(BatchArgument::aggregate_verify_keys(&vks_type_a[1..], &vks_type_b).is_err());
515
516 let open_key_ref = &vks_type_a[0].open_key;
518 let beta_g_ref = &srs.powers_of_g[1];
519 let blinding_factor = Fr377::rand(rng);
520 let (inner1, inner2) = BatchArgument::partial_verify::<RescueTranscript<Fq377>>(
521 beta_g_ref,
522 &open_key_ref.g,
523 &merged_vks,
524 &[shared_public_input],
525 &batch_proof,
526 blinding_factor,
527 )?;
528 assert!(BatchArgument::decide(open_key_ref, inner1, inner2)?);
529
530 {
531 let public_inputs = [[field_switching(&shared_public_input)].as_ref()].concat();
535
536 let (mut circuit, partial_verify_points) = build_circuit::<Bls12_377, Fq377, Param377>(
537 &shared_public_input,
538 &merged_vks,
539 &batch_proof,
540 beta_g_ref,
541 &open_key_ref.g,
542 &blinding_factor,
543 )?;
544
545 assert!(
546 circuit.check_circuit_satisfiability(&public_inputs).is_ok(),
547 "{:?}",
548 circuit.check_circuit_satisfiability(&public_inputs)
549 );
550 assert_eq!(
551 circuit.point_witness(&partial_verify_points.0)?,
552 TEPoint::<Fq377>::from(inner1.into_affine())
553 );
554 assert_eq!(
555 circuit.point_witness(&partial_verify_points.1)?,
556 TEPoint::<Fq377>::from(inner2.into_affine())
557 );
558
559 let wrong_public_inputs = [[Fq377::rand(rng)].as_ref()].concat();
567 assert!(circuit
568 .check_circuit_satisfiability(&wrong_public_inputs)
569 .is_err(),);
570
571 let wrong_public_inputs =
575 [[field_switching(&shared_public_input); 3].as_ref()].concat();
576 assert!(circuit
577 .check_circuit_satisfiability(&wrong_public_inputs)
578 .is_err(),);
579
580 *circuit.witness_mut(10) = Fq377::from(0u32);
584 assert!(circuit
585 .check_circuit_satisfiability(&public_inputs)
586 .is_err());
587 }
588 {
592 let mut wrong_merge_vks = merged_vks.clone();
595 let tmp = wrong_merge_vks.pop().unwrap();
596 assert!(build_circuit::<Bls12_377, Fq377, Param377>(
597 &shared_public_input,
598 &wrong_merge_vks,
599 &batch_proof,
600 beta_g_ref,
601 &open_key_ref.g,
602 &blinding_factor,
603 )
604 .is_err());
605
606 let mut wrong_merge_vks = merged_vks.clone();
609 wrong_merge_vks.push(tmp);
610 assert!(build_circuit::<Bls12_377, Fq377, Param377>(
611 &shared_public_input,
612 &wrong_merge_vks,
613 &batch_proof,
614 beta_g_ref,
615 &open_key_ref.g,
616 &blinding_factor,
617 )
618 .is_err());
619 }
620
621 {
625 let public_inputs = [[field_switching(&shared_public_input)].as_ref()].concat();
628 let wrong_shared_public_input = Fr377::rand(rng);
629 let (circuit, partial_verify_points) = build_circuit::<Bls12_377, Fq377, Param377>(
630 &wrong_shared_public_input,
631 &merged_vks,
632 &batch_proof,
633 beta_g_ref,
634 &open_key_ref.g,
635 &blinding_factor,
636 )?;
637
638 assert!(
639 circuit
640 .check_circuit_satisfiability(&public_inputs)
641 .is_err(),
642 "{:?}",
643 circuit.check_circuit_satisfiability(public_inputs.as_ref())
644 );
645 assert_ne!(
646 circuit.point_witness(&partial_verify_points.0)?,
647 TEPoint::<Fq377>::from(inner1.into_affine())
648 );
649 assert_ne!(
650 circuit.point_witness(&partial_verify_points.1)?,
651 TEPoint::<Fq377>::from(inner2.into_affine())
652 );
653
654 let wrong_public_inputs =
660 [[field_switching(&wrong_shared_public_input)].as_ref()].concat();
661 assert!(
662 circuit
663 .check_circuit_satisfiability(&wrong_public_inputs)
664 .is_ok(),
665 "{:?}",
666 circuit.check_circuit_satisfiability(wrong_public_inputs.as_ref())
667 );
668 assert_ne!(
669 circuit.point_witness(&partial_verify_points.0)?,
670 TEPoint::<Fq377>::from(inner1.into_affine())
671 );
672 assert_ne!(
673 circuit.point_witness(&partial_verify_points.1)?,
674 TEPoint::<Fq377>::from(inner2.into_affine())
675 );
676 }
677
678 Ok(())
679 }
680
681 fn build_circuit<E, F, P>(
682 shared_public_input: &E::ScalarField,
683 merged_vks: &[VerifyingKey<E>],
684 batch_proof: &BatchProof<E>,
685 beta_g_ref: &Affine<P>,
686 generator_g: &Affine<P>,
687 blinding_factor: &E::ScalarField,
688 ) -> Result<(PlonkCircuit<F>, (PointVariable, PointVariable)), CircuitError>
689 where
690 E: Pairing<BaseField = F, G1Affine = Affine<P>>,
691 F: RescueParameter + SWToTEConParam,
692 P: SWCurveConfig<BaseField = F> + TECurveConfig,
693 {
694 let mut circuit = PlonkCircuit::<E::BaseField>::new_ultra_plonk(RANGE_BIT_LEN_FOR_TEST);
695
696 let m = 128;
698 let two_power_m = Some(E::BaseField::from(2u8).pow([m as u64]));
699
700 let shared_public_input_var =
702 circuit.create_public_variable(field_switching(shared_public_input))?;
703 let shared_public_input_fp_elem_var =
704 FpElemVar::new_unchecked(&mut circuit, shared_public_input_var, m, two_power_m)?;
705
706 let vk_vars = merged_vks
708 .iter()
709 .map(|x| VerifyingKeyVar::new(&mut circuit, x))
710 .collect::<Result<Vec<_>, _>>()?;
711
712 let batch_proof_vars = (*batch_proof).create_variables(&mut circuit, m, two_power_m)?;
714
715 let beta_g: TEPoint<F> = (*beta_g_ref).into();
716 let generator_g = &(*generator_g).into();
717 let blinding_factor_var = circuit.create_variable(field_switching(blinding_factor))?;
718
719 let partial_verify_points = VerifyingKeyVar::partial_verify_circuit(
720 &mut circuit,
721 &beta_g,
722 generator_g,
723 &vk_vars,
724 &[shared_public_input_fp_elem_var],
725 &batch_proof_vars,
726 blinding_factor_var,
727 )?;
728
729 Ok((circuit, partial_verify_points))
730 }
731
732 #[test]
733 fn test_variable_independence_for_partial_verification_circuit() -> Result<(), CircuitError> {
734 test_variable_independence_for_partial_verification_circuit_helper::<
735 Bls12_377,
736 _,
737 _,
738 RescueTranscript<_>,
739 >()
740 }
741
742 fn test_variable_independence_for_partial_verification_circuit_helper<E, F, P, T>(
743 ) -> Result<(), CircuitError>
744 where
745 E: Pairing<BaseField = F, G1Affine = Affine<P>>,
746 F: RescueParameter + SWToTEConParam,
747 P: SWCurveConfig<BaseField = F> + TECurveConfig,
748 T: PlonkTranscript<F>,
749 {
750 let rng = &mut test_rng();
751 let i = 8;
752 let mut circuits = vec![];
753
754 let n = 1 << i;
756 let max_degree = n + 2;
757 let srs = PlonkKzgSnark::<E>::universal_setup_for_testing(max_degree, rng)?;
758
759 for _ in 0..2 {
760 let shared_public_input = E::ScalarField::rand(rng);
766 let mut instances_type_a = vec![];
767 let mut instances_type_b = vec![];
768
769 let circuit = new_mergeable_circuit_for_test::<E>(
770 shared_public_input,
771 i,
772 MergeableCircuitType::TypeA,
773 )?;
774 let instance =
775 BatchArgument::setup_instance(&srs, circuit, MergeableCircuitType::TypeA)?;
776 instances_type_a.push(instance);
777
778 let circuit = new_mergeable_circuit_for_test::<E>(
779 shared_public_input,
780 i,
781 MergeableCircuitType::TypeB,
782 )?;
783 let instance =
784 BatchArgument::setup_instance(&srs, circuit, MergeableCircuitType::TypeB)?;
785 instances_type_b.push(instance);
786
787 let batch_proof =
789 BatchArgument::batch_prove::<_, T>(rng, &instances_type_a, &instances_type_b)?;
790
791 let vks_type_a: Vec<&VerifyingKey<E>> = instances_type_a
793 .iter()
794 .map(|pred| pred.verify_key_ref())
795 .collect();
796 let vks_type_b: Vec<&VerifyingKey<E>> = instances_type_b
797 .iter()
798 .map(|pred| pred.verify_key_ref())
799 .collect();
800 let merged_vks = BatchArgument::aggregate_verify_keys(&vks_type_a, &vks_type_b)?;
801
802 let open_key_ref = &vks_type_a[0].open_key;
804 let beta_g_ref = &srs.powers_of_g[1];
805 let blinding_factor = E::ScalarField::rand(rng);
806
807 let (mut circuit, _partial_verify_points) = build_circuit::<E, F, P>(
808 &shared_public_input,
809 &merged_vks,
810 &batch_proof,
811 beta_g_ref,
812 &open_key_ref.g,
813 &blinding_factor,
814 )?;
815
816 circuit.finalize_for_arithmetization()?;
817 circuits.push(circuit);
818 }
819
820 test_variable_independence_for_circuit(circuits[0].clone(), circuits[1].clone())?;
821
822 Ok(())
823 }
824}