refactor: missing circuits in zk-prover [skip-line-limit]

crates/events/src/enclave_event/proof.rs

@@ -36,22 +36,28 @@ impl Proof {
 /// Circuit identifiers for ZK proofs.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum CircuitName {
-    /// BFV public key proof (T0).
+    /// BFV public key proof (C0).
     PkBfv,
-    /// TrBFV public key share proof (T1a).
+    /// TrBFV public key share proof (C1).
     PkGeneration,
-    /// Sk Share computation proof (T1b).
+    /// Sk Share computation proof (C2a).
     SkShareComputation,
-    /// E_SM share computation proof (T1c).
+    /// E_SM share computation proof (C2b).
     ESmShareComputation,
-    /// Encrypted sk share proof (T1d).
+    /// Encrypted sk share proof (C3a).
     SkShareEncryption,
-    /// Encrypted E_SM share proof (T1e).
+    /// Encrypted E_SM share proof (C3b).
     ESmShareEncryption,
-    /// Decryption share proof (T4/T5).
-    DecShares,
-    /// Public key aggregation proof (T6).
-    PkAgg,
+    /// Sk share decryption proof (C4a).
+    DkgSkShareDecryption,
+    /// E_SM share decryption proof (C4b).
+    DkgESmShareDecryption,
+    /// Public key aggregation proof (C5).
+    PkAggregation,
+    /// Decryption share proof (C6).
+    ThresholdShareDecryption,
+    /// Decrypted shares aggregation proof (C7).
+    DecryptedSharesAggregation,
 }
 
 impl CircuitName {
@@ -63,21 +69,27 @@ impl CircuitName {
             CircuitName::ESmShareComputation => "e_sm_share_computation",
             CircuitName::SkShareEncryption => "sk_share_encryption",
             CircuitName::ESmShareEncryption => "e_sm_share_encryption",
-            CircuitName::DecShares => "dec_shares",
-            CircuitName::PkAgg => "pk_agg",
+            CircuitName::DkgSkShareDecryption => "dkg_sk_share_decryption",
+            CircuitName::DkgESmShareDecryption => "dkg_e_sm_share_decryption",
+            CircuitName::PkAggregation => "pk_aggregation",
+            CircuitName::ThresholdShareDecryption => "threshold_share_decryption",
+            CircuitName::DecryptedSharesAggregation => "decrypted_shares_aggregation",
         }
     }
 
     pub fn group(&self) -> &'static str {
         match self {
             CircuitName::PkBfv => "dkg",
-            CircuitName::PkGeneration => "threshold",
             CircuitName::SkShareComputation => "dkg",
             CircuitName::ESmShareComputation => "dkg",
             CircuitName::SkShareEncryption => "dkg",
             CircuitName::ESmShareEncryption => "dkg",
-            CircuitName::DecShares => "threshold",
-            CircuitName::PkAgg => "threshold",
+            CircuitName::DkgSkShareDecryption => "dkg",
+            CircuitName::DkgESmShareDecryption => "dkg",
+            CircuitName::PkGeneration => "threshold",
+            CircuitName::ThresholdShareDecryption => "threshold",
+            CircuitName::PkAggregation => "threshold",
+            CircuitName::DecryptedSharesAggregation => "threshold",
         }
     }
 

crates/events/src/enclave_event/signed_proof.rs

@@ -47,6 +47,8 @@ pub enum ProofType {
     T2ESmShareDecryption = 7,
     /// T5 — Share decryption proof (Proof 6).
     T5ShareDecryption = 8,
+    /// T6 — Decrypted shares aggregation proof (Proof 7).
+    T6DecryptedSharesAggregation = 9,
 }
 
 impl ProofType {
@@ -59,10 +61,10 @@ impl ProofType {
             ProofType::T1ESmShareComputation => CircuitName::ESmShareComputation,
             ProofType::T1SkShareEncryption => CircuitName::SkShareEncryption,
             ProofType::T1ESmShareEncryption => CircuitName::ESmShareEncryption,
-            ProofType::T2SkShareDecryption | ProofType::T2ESmShareDecryption => {
-                CircuitName::DecShares
-            }
-            ProofType::T5ShareDecryption => CircuitName::DecShares,
+            ProofType::T2SkShareDecryption => CircuitName::DkgSkShareDecryption,
+            ProofType::T2ESmShareDecryption => CircuitName::DkgESmShareDecryption,
+            ProofType::T5ShareDecryption => CircuitName::ThresholdShareDecryption,
+            ProofType::T6DecryptedSharesAggregation => CircuitName::DecryptedSharesAggregation,
         }
     }
 
@@ -78,6 +80,7 @@ impl ProofType {
             | ProofType::T2SkShareDecryption
             | ProofType::T2ESmShareDecryption => "E3_BAD_DKG_PROOF",
             ProofType::T5ShareDecryption => "E3_BAD_DECRYPTION_PROOF",
+            ProofType::T6DecryptedSharesAggregation => "E3_BAD_AGGREGATION_PROOF",
         }
     }
 }
@@ -309,7 +312,11 @@ mod tests {
         );
         assert_eq!(
             ProofType::T2SkShareDecryption.circuit_name(),
-            CircuitName::DecShares
+            CircuitName::DkgSkShareDecryption
+        );
+        assert_eq!(
+            ProofType::T5ShareDecryption.circuit_name(),
+            CircuitName::ThresholdShareDecryption
         );
     }
 }

crates/zk-helpers/src/circuits/dkg/share_decryption/circuit.rs

@@ -30,4 +30,6 @@ pub struct ShareDecryptionCircuitData {
     pub secret_key: SecretKey,
     /// Ciphertexts from H honest parties: [party_idx][mod_idx] (one ciphertext per party per TRBFV modulus).
     pub honest_ciphertexts: Vec<Vec<Ciphertext>>,
+    /// Which input type (SecretKey or SmudgingNoise) to resolve circuit path.
+    pub dkg_input_type: DkgInputType,
 }

crates/zk-helpers/src/circuits/dkg/share_decryption/sample.rs

@@ -130,6 +130,7 @@ impl ShareDecryptionCircuitData {
         Ok(ShareDecryptionCircuitData {
             honest_ciphertexts,
             secret_key: dkg_secret_key,
+            dkg_input_type,
         })
     }
 }

crates/zk-prover/src/circuits/dkg/mod.rs

@@ -6,4 +6,5 @@
 
 mod pk;
 mod share_computation;
+mod share_decryption;
 mod share_encryption;

crates/zk-prover/src/circuits/dkg/share_computation.rs

@@ -11,7 +11,6 @@ use e3_zk_helpers::computation::DkgInputType;
 use e3_zk_helpers::dkg::share_computation::{
     Inputs, ShareComputationCircuit, ShareComputationCircuitData,
 };
-use noirc_abi::InputMap;
 
 impl Provable for ShareComputationCircuit {
     type Params = BfvPreset;

crates/zk-prover/src/circuits/dkg/share_decryption.rs

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE
+
+use crate::traits::Provable;
+use e3_events::CircuitName;
+use e3_fhe_params::BfvPreset;
+use e3_zk_helpers::computation::DkgInputType;
+use e3_zk_helpers::dkg::share_decryption::{
+    Inputs, ShareDecryptionCircuit, ShareDecryptionCircuitData,
+};
+
+impl Provable for ShareDecryptionCircuit {
+    type Params = BfvPreset;
+    type Input = ShareDecryptionCircuitData;
+    type Inputs = Inputs;
+
+    fn resolve_circuit_name(&self, input: &Self::Input) -> CircuitName {
+        match input.dkg_input_type {
+            DkgInputType::SecretKey => CircuitName::DkgSkShareDecryption,
+            DkgInputType::SmudgingNoise => CircuitName::DkgESmShareDecryption,
+        }
+    }
+
+    fn valid_circuits(&self) -> Vec<CircuitName> {
+        vec![
+            CircuitName::DkgSkShareDecryption,
+            CircuitName::DkgESmShareDecryption,
+        ]
+    }
+
+    fn circuit(&self) -> CircuitName {
+        CircuitName::DkgSkShareDecryption
+    }
+}

crates/zk-prover/src/circuits/threshold/decrypted_shares_aggregation.rs

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE
+
+use crate::traits::Provable;
+use e3_events::CircuitName;
+use e3_fhe_params::BfvPreset;
+use e3_zk_helpers::circuits::threshold::decrypted_shares_aggregation::circuit::{
+    DecryptedSharesAggregationCircuit, DecryptedSharesAggregationCircuitData,
+};
+use e3_zk_helpers::circuits::threshold::decrypted_shares_aggregation::computation::Inputs;
+
+impl Provable for DecryptedSharesAggregationCircuit {
+    type Params = BfvPreset;
+    type Input = DecryptedSharesAggregationCircuitData;
+    type Inputs = Inputs;
+
+    fn circuit(&self) -> CircuitName {
+        CircuitName::DecryptedSharesAggregation
+    }
+}

crates/zk-prover/src/circuits/threshold/mod.rs

@@ -4,4 +4,7 @@
 // without even the implied warranty of MERCHANTABILITY
 // or FITNESS FOR A PARTICULAR PURPOSE.
 
+mod decrypted_shares_aggregation;
+mod pk_aggregation;
 mod pk_generation;
+mod share_decryption;

crates/zk-prover/src/circuits/threshold/pk_aggregation.rs

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE
+
+use crate::traits::Provable;
+use e3_events::CircuitName;
+use e3_fhe_params::BfvPreset;
+use e3_zk_helpers::circuits::threshold::pk_aggregation::circuit::{
+    PkAggregationCircuit, PkAggregationCircuitData,
+};
+use e3_zk_helpers::circuits::threshold::pk_aggregation::computation::Inputs;
+
+impl Provable for PkAggregationCircuit {
+    type Params = BfvPreset;
+    type Input = PkAggregationCircuitData;
+    type Inputs = Inputs;
+
+    fn circuit(&self) -> CircuitName {
+        CircuitName::PkAggregation
+    }
+}

crates/zk-prover/src/circuits/threshold/share_decryption.rs

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE
+
+use crate::traits::Provable;
+use e3_events::CircuitName;
+use e3_fhe_params::BfvPreset;
+use e3_zk_helpers::circuits::threshold::share_decryption::circuit::{
+    ShareDecryptionCircuit, ShareDecryptionCircuitData,
+};
+use e3_zk_helpers::circuits::threshold::share_decryption::computation::Inputs;
+
+impl Provable for ShareDecryptionCircuit {
+    type Params = BfvPreset;
+    type Input = ShareDecryptionCircuitData;
+    type Inputs = Inputs;
+
+    fn circuit(&self) -> CircuitName {
+        CircuitName::ThresholdShareDecryption
+    }
+}