feat: e3 refund timeout mechanism [skip-line-limit]

crates/aggregator/src/committee_finalizer.rs

@@ -61,7 +61,7 @@ impl Handler<CommitteeRequested> for CommitteeFinalizer {
 
     fn handle(&mut self, msg: CommitteeRequested, ctx: &mut Self::Context) -> Self::Result {
         let e3_id = msg.e3_id.clone();
-        let submission_deadline = msg.submission_deadline;
+        let committee_deadline = msg.committee_deadline;
 
         const FINALIZATION_BUFFER_SECONDS: u64 = 1;
 
@@ -85,12 +85,12 @@ impl Handler<CommitteeRequested> for CommitteeFinalizer {
             fut.into_actor(self)
                 .then(move |current_timestamp, act, ctx| {
                     if let Some(current_timestamp) = current_timestamp {
-                        let seconds_until_deadline = if submission_deadline > current_timestamp {
-                            (submission_deadline - current_timestamp) + FINALIZATION_BUFFER_SECONDS
+                        let seconds_until_deadline = if committee_deadline > current_timestamp {
+                            (committee_deadline - current_timestamp) + FINALIZATION_BUFFER_SECONDS
                         } else {
                             info!(
                                 e3_id = %e3_id_for_async,
-                                submission_deadline = submission_deadline,
+                                committee_deadline = committee_deadline,
                                 current_timestamp = current_timestamp,
                                 "Submission deadline already passed, finalizing with buffer"
                             );
@@ -99,7 +99,7 @@ impl Handler<CommitteeRequested> for CommitteeFinalizer {
 
                         info!(
                             e3_id = %e3_id_for_async,
-                            submission_deadline = submission_deadline,
+                            committee_deadline = committee_deadline,
                             current_timestamp = current_timestamp,
                             seconds_to_wait = seconds_until_deadline,
                             "Scheduling committee finalization"

crates/events/src/enclave_event/committee_requested.rs

@@ -16,16 +16,16 @@ pub struct CommitteeRequested {
     pub seed: Seed,
     pub threshold: [usize; 2],
     pub request_block: u64,
-    pub submission_deadline: u64,
+    pub committee_deadline: u64,
     pub chain_id: u64,
 }
 
 impl Display for CommitteeRequested {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
-            "e3_id: {}, seed: {:?}, threshold: [{}, {}], request_block: {}, submission_deadline: {}, chain_id: {}",
-            self.e3_id, self.seed, self.threshold[0], self.threshold[1], self.request_block, self.submission_deadline, self.chain_id
+            "e3_id: {}, seed: {:?}, threshold: [{}, {}], request_block: {}, committee_deadline: {}, chain_id: {}",
+            self.e3_id, self.seed, self.threshold[0], self.threshold[1], self.request_block, self.committee_deadline, self.chain_id
         )
     }
 }

crates/events/src/enclave_event/e3_failed.rs

@@ -0,0 +1,58 @@
+// 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::E3id;
+use actix::Message;
+use serde::{Deserialize, Serialize};
+use std::fmt::{self, Display};
+
+/// Reason why an E3 failed
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum FailureReason {
+    None,
+    CommitteeFormationTimeout,
+    InsufficientCommitteeMembers,
+    DKGTimeout,
+    DKGInvalidShares,
+    NoInputsReceived,
+    ComputeTimeout,
+    ComputeProviderExpired,
+    ComputeProviderFailed,
+    RequesterCancelled,
+    DecryptionTimeout,
+    DecryptionInvalidShares,
+    VerificationFailed,
+}
+
+/// E3 lifecycle stage
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum E3Stage {
+    None,
+    Requested,
+    CommitteeFinalized,
+    KeyPublished,
+    CiphertextReady,
+    Complete,
+    Failed,
+}
+
+#[derive(Message, Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[rtype(result = "()")]
+pub struct E3Failed {
+    pub e3_id: E3id,
+    pub failed_at_stage: E3Stage,
+    pub reason: FailureReason,
+}
+
+impl Display for E3Failed {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "E3Failed {{ e3_id: {}, stage: {:?}, reason: {:?} }}",
+            self.e3_id, self.failed_at_stage, self.reason
+        )
+    }
+}

crates/events/src/enclave_event/e3_stage_changed.rs

@@ -0,0 +1,31 @@
+// 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::E3id;
+use actix::Message;
+use serde::{Deserialize, Serialize};
+use std::fmt::{self, Display};
+
+// Re-export E3Stage from e3_failed to avoid duplication
+pub use super::e3_failed::E3Stage;
+
+#[derive(Message, Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[rtype(result = "()")]
+pub struct E3StageChanged {
+    pub e3_id: E3id,
+    pub previous_stage: E3Stage,
+    pub new_stage: E3Stage,
+}
+
+impl Display for E3StageChanged {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "E3StageChanged {{ e3_id: {}, {:?} -> {:?} }}",
+            self.e3_id, self.previous_stage, self.new_stage
+        )
+    }
+}

crates/events/src/enclave_event/mod.rs

@@ -16,8 +16,10 @@ mod compute_request;
 mod configuration_updated;
 mod decryptionshare_created;
 mod die;
+mod e3_failed;
 mod e3_request_complete;
 mod e3_requested;
+mod e3_stage_changed;
 mod enclave_error;
 mod encryption_key_collection_failed;
 mod encryption_key_created;
@@ -57,8 +59,10 @@ pub use compute_request::*;
 pub use configuration_updated::*;
 pub use decryptionshare_created::*;
 pub use die::*;
+pub use e3_failed::*;
 pub use e3_request_complete::*;
 pub use e3_requested::*;
+pub use e3_stage_changed::*;
 use e3_utils::{colorize, Color};
 pub use enclave_error::*;
 pub use encryption_key_collection_failed::*;
@@ -206,6 +210,8 @@ pub enum EnclaveEventData {
     PlaintextOutputPublished(PlaintextOutputPublished),
     EnclaveError(EnclaveError),
     E3RequestComplete(E3RequestComplete),
+    E3Failed(E3Failed),
+    E3StageChanged(E3StageChanged),
     Shutdown(Shutdown),
     DocumentReceived(DocumentReceived),
     ThresholdShareCreated(ThresholdShareCreated),
@@ -432,6 +438,8 @@ impl EnclaveEventData {
             EnclaveEventData::TicketSubmitted(ref data) => Some(data.e3_id.clone()),
             EnclaveEventData::EncryptionKeyCreated(ref data) => Some(data.e3_id.clone()),
             EnclaveEventData::ComputeResponse(ref data) => Some(data.e3_id.clone()),
+            EnclaveEventData::E3Failed(ref data) => Some(data.e3_id.clone()),
+            EnclaveEventData::E3StageChanged(ref data) => Some(data.e3_id.clone()),
             _ => None,
         }
     }
@@ -469,6 +477,8 @@ impl_event_types!(
     PlaintextAggregated,
     PublishDocumentRequested,
     E3RequestComplete,
+    E3Failed,
+    E3StageChanged,
     CiphernodeSelected,
     CiphernodeAdded,
     CiphernodeRemoved,