feat: integrate recursive aggregation into zk flow [skip-line-limit]

.github/workflows/ci.yml

@@ -722,6 +722,9 @@ jobs:
           path: |
             circuits/bin/dkg/target/
             circuits/bin/threshold/target/
+            circuits/bin/recursive_aggregation/wrapper/dkg/target/
+            circuits/bin/recursive_aggregation/wrapper/threshold/target/
+            circuits/bin/recursive_aggregation/fold/target/
           retention-days: 1
           if-no-files-found: error
 

circuits/bin/recursive_aggregation/wrapper/dkg/pk/src/main.nr

@@ -4,7 +4,7 @@
 // without even the implied warranty of MERCHANTABILITY
 // or FITNESS FOR A PARTICULAR PURPOSE.
 
-use bb_proof_verification::{UltraHonkProof, UltraHonkVerificationKey, verify_honk_proof_non_zk};
+use bb_proof_verification::{UltraHonkVerificationKey, UltraHonkZKProof, verify_honk_proof};
 use lib::math::commitments::compute_recursive_aggregation_commitment;
 
 // Number of proofs.
@@ -14,12 +14,12 @@ pub global N_PUBLIC_INPUTS: u32 = 1;
 
 fn main(
     verification_key: UltraHonkVerificationKey,
-    proofs: [UltraHonkProof; N_PROOFS],
+    proofs: [UltraHonkZKProof; N_PROOFS],
     public_inputs: [[Field; N_PUBLIC_INPUTS]; N_PROOFS],
     key_hash: pub Field,
 ) -> pub Field {
     for i in 0..N_PROOFS {
-        verify_honk_proof_non_zk(verification_key, proofs[i], public_inputs[i], key_hash);
+        verify_honk_proof(verification_key, proofs[i], public_inputs[i], key_hash);
     }
 
     let mut aggregated_public_inputs = Vec::new();

circuits/bin/recursive_aggregation/wrapper/dkg/share_computation/src/main.nr

@@ -4,23 +4,23 @@
 // without even the implied warranty of MERCHANTABILITY
 // or FITNESS FOR A PARTICULAR PURPOSE.
 
-use bb_proof_verification::{UltraHonkProof, UltraHonkVerificationKey, verify_honk_proof_non_zk};
+use bb_proof_verification::{UltraHonkVerificationKey, UltraHonkZKProof, verify_honk_proof};
 use lib::configs::default::dkg::L_THRESHOLD;
 use lib::{configs::default::N_PARTIES, math::commitments::compute_recursive_aggregation_commitment};
 
 // Number of proofs.
-pub global N_PROOFS: u32 = 2;
+pub global N_PROOFS: u32 = 1;
 /// Number of public inputs/outputs per proof.
 pub global N_PUBLIC_INPUTS: u32 = (L_THRESHOLD * N_PARTIES) + 1;
 
 fn main(
     verification_key: UltraHonkVerificationKey,
-    proofs: [UltraHonkProof; N_PROOFS],
+    proofs: [UltraHonkZKProof; N_PROOFS],
     public_inputs: [[Field; N_PUBLIC_INPUTS]; N_PROOFS],
     key_hash: pub Field,
 ) -> pub Field {
     for i in 0..N_PROOFS {
-        verify_honk_proof_non_zk(verification_key, proofs[i], public_inputs[i], key_hash);
+        verify_honk_proof(verification_key, proofs[i], public_inputs[i], key_hash);
     }
 
     let mut aggregated_public_inputs = Vec::new();

circuits/bin/recursive_aggregation/wrapper/dkg/share_decryption/src/main.nr

@@ -4,24 +4,24 @@
 // without even the implied warranty of MERCHANTABILITY
 // or FITNESS FOR A PARTICULAR PURPOSE.
 
-use bb_proof_verification::{UltraHonkProof, UltraHonkVerificationKey, verify_honk_proof_non_zk};
+use bb_proof_verification::{UltraHonkVerificationKey, UltraHonkZKProof, verify_honk_proof};
 use lib::configs::default::dkg::L_THRESHOLD;
 use lib::configs::default::H;
 use lib::math::commitments::compute_recursive_aggregation_commitment;
 
 // Number of proofs.
-pub global N_PROOFS: u32 = 2;
+pub global N_PROOFS: u32 = 1;
 /// Number of public inputs/outputs per proof.
 pub global N_PUBLIC_INPUTS: u32 = (H * L_THRESHOLD) + 1;
 
 fn main(
     verification_key: UltraHonkVerificationKey,
-    proofs: [UltraHonkProof; N_PROOFS],
+    proofs: [UltraHonkZKProof; N_PROOFS],
     public_inputs: [[Field; N_PUBLIC_INPUTS]; N_PROOFS],
     key_hash: pub Field,
 ) -> pub Field {
     for i in 0..N_PROOFS {
-        verify_honk_proof_non_zk(verification_key, proofs[i], public_inputs[i], key_hash);
+        verify_honk_proof(verification_key, proofs[i], public_inputs[i], key_hash);
     }
 
     let mut aggregated_public_inputs = Vec::new();

circuits/bin/recursive_aggregation/wrapper/dkg/share_encryption/src/main.nr

@@ -4,25 +4,25 @@
 // without even the implied warranty of MERCHANTABILITY
 // or FITNESS FOR A PARTICULAR PURPOSE.
 
-use bb_proof_verification::{UltraHonkProof, UltraHonkVerificationKey, verify_honk_proof_non_zk};
+use bb_proof_verification::{UltraHonkVerificationKey, UltraHonkZKProof, verify_honk_proof};
 use lib::{
     configs::default::dkg::{L, N},
     math::commitments::compute_recursive_aggregation_commitment,
 };
 
 // Number of proofs.
-pub global N_PROOFS: u32 = 2;
+pub global N_PROOFS: u32 = 1;
 /// Number of public inputs/outputs per proof.
 pub global N_PUBLIC_INPUTS: u32 = (2 * L * N) + 2;
 
 fn main(
     verification_key: UltraHonkVerificationKey,
-    proofs: [UltraHonkProof; N_PROOFS],
+    proofs: [UltraHonkZKProof; N_PROOFS],
     public_inputs: [[Field; N_PUBLIC_INPUTS]; N_PROOFS],
     key_hash: pub Field,
 ) -> pub Field {
     for i in 0..N_PROOFS {
-        verify_honk_proof_non_zk(verification_key, proofs[i], public_inputs[i], key_hash);
+        verify_honk_proof(verification_key, proofs[i], public_inputs[i], key_hash);
     }
 
     let mut aggregated_public_inputs = Vec::new();

circuits/bin/recursive_aggregation/wrapper/threshold/decrypted_shares_aggregation/src/main.nr

@@ -4,7 +4,7 @@
 // without even the implied warranty of MERCHANTABILITY
 // or FITNESS FOR A PARTICULAR PURPOSE.
 
-use bb_proof_verification::{UltraHonkProof, UltraHonkVerificationKey, verify_honk_proof_non_zk};
+use bb_proof_verification::{UltraHonkVerificationKey, UltraHonkZKProof, verify_honk_proof};
 use lib::{
     configs::default::{MAX_MSG_NON_ZERO_COEFFS, T, threshold::L},
     math::commitments::compute_recursive_aggregation_commitment,
@@ -18,12 +18,12 @@ pub global N_PUBLIC_INPUTS: u32 =
 
 fn main(
     verification_key: UltraHonkVerificationKey,
-    proofs: [UltraHonkProof; N_PROOFS],
+    proofs: [UltraHonkZKProof; N_PROOFS],
     public_inputs: [[Field; N_PUBLIC_INPUTS]; N_PROOFS],
     key_hash: pub Field,
 ) -> pub Field {
     for i in 0..N_PROOFS {
-        verify_honk_proof_non_zk(verification_key, proofs[i], public_inputs[i], key_hash);
+        verify_honk_proof(verification_key, proofs[i], public_inputs[i], key_hash);
     }
 
     let mut aggregated_public_inputs = Vec::new();

circuits/bin/recursive_aggregation/wrapper/threshold/pk_aggregation/src/main.nr

@@ -4,7 +4,7 @@
 // without even the implied warranty of MERCHANTABILITY
 // or FITNESS FOR A PARTICULAR PURPOSE.
 
-use bb_proof_verification::{UltraHonkProof, UltraHonkVerificationKey, verify_honk_proof_non_zk};
+use bb_proof_verification::{UltraHonkVerificationKey, UltraHonkZKProof, verify_honk_proof};
 use lib::{configs::default::H, math::commitments::compute_recursive_aggregation_commitment};
 
 // Number of proofs.
@@ -14,12 +14,12 @@ pub global N_PUBLIC_INPUTS: u32 = H + 1;
 
 fn main(
     verification_key: UltraHonkVerificationKey,
-    proofs: [UltraHonkProof; N_PROOFS],
+    proofs: [UltraHonkZKProof; N_PROOFS],
     public_inputs: [[Field; N_PUBLIC_INPUTS]; N_PROOFS],
     key_hash: pub Field,
 ) -> pub Field {
     for i in 0..N_PROOFS {
-        verify_honk_proof_non_zk(verification_key, proofs[i], public_inputs[i], key_hash);
+        verify_honk_proof(verification_key, proofs[i], public_inputs[i], key_hash);
     }
 
     let mut aggregated_public_inputs = Vec::new();

circuits/bin/recursive_aggregation/wrapper/threshold/pk_generation/src/main.nr

@@ -4,23 +4,22 @@
 // without even the implied warranty of MERCHANTABILITY
 // or FITNESS FOR A PARTICULAR PURPOSE.
 
-use bb_proof_verification::{UltraHonkProof, UltraHonkVerificationKey, verify_honk_proof_non_zk};
-use lib::configs::default::threshold::{L, N};
+use bb_proof_verification::{UltraHonkVerificationKey, UltraHonkZKProof, verify_honk_proof};
 use lib::math::commitments::compute_recursive_aggregation_commitment;
 
 // Number of proofs.
 pub global N_PROOFS: u32 = 1;
-/// Number of public inputs/outputs per proof.
-pub global N_PUBLIC_INPUTS: u32 = (L * N) + 3;
+/// Number of public inputs/outputs per proof (sk_commitment, pk_commitment, e_sm_commitment).
+pub global N_PUBLIC_INPUTS: u32 = 3;
 
 fn main(
     verification_key: UltraHonkVerificationKey,
-    proofs: [UltraHonkProof; N_PROOFS],
+    proofs: [UltraHonkZKProof; N_PROOFS],
     public_inputs: [[Field; N_PUBLIC_INPUTS]; N_PROOFS],
     key_hash: pub Field,
 ) -> pub Field {
     for i in 0..N_PROOFS {
-        verify_honk_proof_non_zk(verification_key, proofs[i], public_inputs[i], key_hash);
+        verify_honk_proof(verification_key, proofs[i], public_inputs[i], key_hash);
     }
 
     let mut aggregated_public_inputs = Vec::new();

circuits/bin/recursive_aggregation/wrapper/threshold/share_decryption/src/main.nr

@@ -4,23 +4,23 @@
 // without even the implied warranty of MERCHANTABILITY
 // or FITNESS FOR A PARTICULAR PURPOSE.
 
-use bb_proof_verification::{UltraHonkProof, UltraHonkVerificationKey, verify_honk_proof_non_zk};
+use bb_proof_verification::{UltraHonkVerificationKey, UltraHonkZKProof, verify_honk_proof};
 use lib::configs::default::threshold::{L, N};
 use lib::math::commitments::compute_recursive_aggregation_commitment;
 
 // Number of proofs.
 pub global N_PROOFS: u32 = 1;
 /// Number of public inputs/outputs per proof.
-pub global N_PUBLIC_INPUTS: u32 = 2 + 3 * L * N;
+pub global N_PUBLIC_INPUTS: u32 = 2 + 2 * L * N;
 
 fn main(
     verification_key: UltraHonkVerificationKey,
-    proofs: [UltraHonkProof; N_PROOFS],
+    proofs: [UltraHonkZKProof; N_PROOFS],
     public_inputs: [[Field; N_PUBLIC_INPUTS]; N_PROOFS],
     key_hash: pub Field,
 ) -> pub Field {
     for i in 0..N_PROOFS {
-        verify_honk_proof_non_zk(verification_key, proofs[i], public_inputs[i], key_hash);
+        verify_honk_proof(verification_key, proofs[i], public_inputs[i], key_hash);
     }
 
     let mut aggregated_public_inputs = Vec::new();

crates/aggregator/src/lib.rs

@@ -7,6 +7,7 @@
 mod committee_finalizer;
 pub mod ext;
 mod keyshare_created_filter_buffer;
+mod proof_fold;
 mod publickey_aggregator;
 mod repo;
 mod threshold_plaintext_aggregator;