fix: do not broadcast sk_poly_sum and es_poly_sum

crates/events/src/enclave_event/decryption_key_shared.rs

@@ -22,11 +22,6 @@ pub struct DecryptionKeyShared {
     pub party_id: u64,
     /// The sender's node address.
     pub node: String,
-    /// Lagrange-interpolated aggregated SK polynomial (serialized).
-    #[derivative(Debug(format_with = "e3_utils::formatters::hexf"))]
-    pub sk_poly_sum: ArcBytes,
-    /// Lagrange-interpolated aggregated E_SM polynomials (serialized), one per smudging noise.
-    pub es_poly_sum: Vec<ArcBytes>,
     /// ECDSA-signed C4a proof (SecretKey decryption) for verification and fault attribution.
     pub signed_sk_decryption_proof: SignedProofPayload,
     /// ECDSA-signed C4b proofs (SmudgingNoise decryption), one per smudging noise index.

crates/events/src/enclave_event/decryption_share_proofs.rs

@@ -17,18 +17,13 @@ use serde::{Deserialize, Serialize};
 
 /// ThresholdKeyshare → ProofRequestActor: generate and sign C4 proofs.
 ///
-/// Carries both the proof generation inputs (sk_request, esm_requests)
-/// and the protocol data (sk_poly_sum, es_poly_sum, node) so that
-/// ProofRequestActor can publish `DecryptionKeyShared` directly.
+/// Carries the proof generation inputs (sk_request, esm_requests) and node
+/// info so that ProofRequestActor can publish `DecryptionKeyShared` directly.
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct DecryptionShareProofsPending {
     pub e3_id: E3id,
     pub party_id: u64,
     pub node: String,
-    /// Decrypted SK polynomial sum (for Exchange #3).
-    pub sk_poly_sum: ArcBytes,
-    /// Decrypted ES polynomial sums (for Exchange #3).
-    pub es_poly_sum: Vec<ArcBytes>,
     /// C4a proof request (SecretKey decryption).
     pub sk_request: DkgShareDecryptionProofRequest,
     /// C4b proof requests (SmudgingNoise decryption), one per ESI index.

crates/keyshare/src/threshold_keyshare.rs

@@ -1884,17 +1884,6 @@ impl ThresholdKeyshare {
         let party_id = state.party_id;
         let node = state.address.clone();
 
-        let ready: ReadyForDecryption = state.clone().try_into()?;
-        let sk_poly_sum_bytes = ready.sk_poly_sum.access(&self.cipher)?;
-        let es_poly_sum_bytes: Vec<ArcBytes> = ready
-            .es_poly_sum
-            .iter()
-            .map(|s| {
-                let bytes = s.access(&self.cipher)?;
-                Ok(ArcBytes::from_bytes(&bytes))
-            })
-            .collect::<Result<_>>()?;
-
         info!(
             "Publishing DecryptionShareProofsPending for E3 {} party {} (1 SK + {} ESM requests)",
             e3_id,
@@ -1907,8 +1896,6 @@ impl ThresholdKeyshare {
                 e3_id: e3_id.clone(),
                 party_id,
                 node,
-                sk_poly_sum: ArcBytes::from_bytes(&sk_poly_sum_bytes),
-                es_poly_sum: es_poly_sum_bytes,
                 sk_request,
                 esm_requests,
             },

crates/zk-prover/src/actors/proof_request.rs

@@ -164,8 +164,6 @@ enum DecryptionProofKind {
 struct PendingDecryptionProofs {
     party_id: u64,
     node: String,
-    sk_poly_sum: ArcBytes,
-    es_poly_sum: Vec<ArcBytes>,
     ec: EventContext<Sequenced>,
     sk_proof: Option<Proof>,
     esm_proofs: HashMap<usize, Proof>,
@@ -572,8 +570,6 @@ impl ProofRequestActor {
             PendingDecryptionProofs {
                 party_id: msg.party_id,
                 node: msg.node,
-                sk_poly_sum: msg.sk_poly_sum,
-                es_poly_sum: msg.es_poly_sum,
                 ec: ec.clone(),
                 sk_proof: None,
                 esm_proofs: HashMap::new(),
@@ -753,8 +749,6 @@ impl ProofRequestActor {
                 e3_id: e3_id.clone(),
                 party_id: pending.party_id,
                 node: pending.node,
-                sk_poly_sum: pending.sk_poly_sum,
-                es_poly_sum: pending.es_poly_sum,
                 signed_sk_decryption_proof: signed_sk,
                 signed_e_sm_decryption_proofs: signed_esms,
                 external: false,