optimize signature verify

Author: ed255

src/backends/plonky2/primitives/signature_circuit.rs

@@ -39,7 +39,6 @@ pub struct SignatureVerifyTarget {
     msg: ValueTarget,
     // proof of the SignatureInternalCircuit (=signature::Signature.0)
     proof: ProofWithPublicInputsTarget<D>,
-    dummy_proof: ProofWithPublicInputsTarget<D>,
 }
 
 impl SignatureVerifyGadget {
@@ -73,42 +72,46 @@ impl SignatureVerifyGadget {
 
         let proof_targ = builder.add_virtual_proof_with_pis(&common_data);
 
-        // connect the {pk, msg, s} with the proof_targ.public_inputs
+        let dummy_pi = DUMMY_PUBLIC_INPUTS.clone();
+
+        let pk_targ_dummy =
+            builder.constant_value(Value(dummy_pi[..VALUE_SIZE].try_into().unwrap()));
+        let msg_targ_dummy = builder.constant_value(Value(
+            dummy_pi[VALUE_SIZE..VALUE_SIZE * 2].try_into().unwrap(),
+        ));
+        let s_targ_dummy =
+            builder.constant_value(Value(dummy_pi[VALUE_SIZE * 2..].try_into().unwrap()));
+
+        // connect the {pk, msg, s} with the proof_targ.public_inputs conditionally
+        let pk_targ_connect = builder.select_value(selector, pk_targ, pk_targ_dummy);
+        let msg_targ_connect = builder.select_value(selector, msg_targ, msg_targ_dummy);
+        let s_targ_connect = builder.select_value(
+            selector,
+            ValueTarget {
+                elements: s_targ.elements,
+            },
+            s_targ_dummy,
+        );
         for i in 0..VALUE_SIZE {
-            builder.connect(pk_targ.elements[i], proof_targ.public_inputs[i]);
+            builder.connect(pk_targ_connect.elements[i], proof_targ.public_inputs[i]);
             builder.connect(
-                msg_targ.elements[i],
+                msg_targ_connect.elements[i],
                 proof_targ.public_inputs[VALUE_SIZE + i],
             );
             builder.connect(
-                s_targ.elements[i],
+                s_targ_connect.elements[i],
                 proof_targ.public_inputs[(2 * VALUE_SIZE) + i],
             );
         }
 
-        // NOTE: we would use the `conditional_verify_proof_or_dummy` method,
-        // but since we're using the `standard_recursion_zk_config` (with zk),
-        // internally it fails to generate the `dummy_circuit`, which mentions
-        // that degree calculation could be off if zk is enabled. So we use
-        // `conditional_verify_proof` feeding in our own dummy_proof
-        // (signature::DUMMY_PROOF).
-        let dummy_proof_targ = builder.add_virtual_proof_with_pis(&common_data);
-        builder.conditionally_verify_proof::<C>(
-            selector,
-            &proof_targ,
-            &verifier_data_targ,
-            &dummy_proof_targ,
-            &verifier_data_targ,
-            &common_data,
-        );
+        builder.verify_proof::<C>(&proof_targ, &verifier_data_targ, &common_data);
 
         Ok(SignatureVerifyTarget {
             verifier_data_targ,
             selector,
             pk: pk_targ,
             msg: msg_targ,
             proof: proof_targ,
-            dummy_proof: dummy_proof_targ,
         })
     }
 }
@@ -131,21 +134,23 @@ impl SignatureVerifyTarget {
         let s = Value(PoseidonHash::hash_no_pad(&[pk.0 .0, msg.0].concat()).elements);
         let public_inputs: Vec<F> = [pk.0 .0, msg.0, s.0].concat();
 
-        pw.set_proof_with_pis_target(
-            &self.proof,
-            &ProofWithPublicInputs {
-                proof: signature.0,
-                public_inputs,
-            },
-        )?;
-
-        pw.set_proof_with_pis_target(
-            &self.dummy_proof,
-            &ProofWithPublicInputs {
-                proof: DUMMY_SIGNATURE.0.clone(),
-                public_inputs: DUMMY_PUBLIC_INPUTS.clone(),
-            },
-        )?;
+        if selector {
+            pw.set_proof_with_pis_target(
+                &self.proof,
+                &ProofWithPublicInputs {
+                    proof: signature.0,
+                    public_inputs,
+                },
+            )?;
+        } else {
+            pw.set_proof_with_pis_target(
+                &self.proof,
+                &ProofWithPublicInputs {
+                    proof: DUMMY_SIGNATURE.0.clone(),
+                    public_inputs: DUMMY_PUBLIC_INPUTS.clone(),
+                },
+            )?;
+        }
 
         pw.set_verifier_data_target(
             &self.verifier_data_targ,