remove reducer_outcome

Author: Shubham8287

crates/client-api/src/routes/database.rs

@@ -311,7 +311,6 @@ pub async fn call_from_database<S: ControlStateDelegate + NodeDelegate>(
         Ok(rcr) => {
             let (status, body) = match rcr.outcome {
                 ReducerOutcome::Committed => (StatusCode::OK, "".into()),
-                ReducerOutcome::Deduplicated => (StatusCode::OK, "deduplicated".into()),
                 // 422 = reducer ran but returned Err; the IDC actor uses this to distinguish
                 // reducer failures from transport errors (which it retries).
                 ReducerOutcome::Failed(errmsg) => (StatusCode::UNPROCESSABLE_ENTITY, *errmsg),
@@ -351,7 +350,7 @@ fn reducer_outcome_response(
     outcome: ReducerOutcome,
 ) -> (StatusCode, Box<str>) {
     match outcome {
-        ReducerOutcome::Committed | ReducerOutcome::Deduplicated => (StatusCode::OK, "".into()),
+        ReducerOutcome::Committed => (StatusCode::OK, "".into()),
         ReducerOutcome::Failed(errmsg) => {
             // TODO: different status code? this is what cloudflare uses, sorta
             (StatusCode::from_u16(530).unwrap(), *errmsg)

crates/core/src/host/host_controller.rs

@@ -165,22 +165,19 @@ pub enum ReducerOutcome {
     Committed,
     Failed(Box<Box<str>>),
     BudgetExceeded,
-    /// The call was identified as a duplicate via the `st_databases_tx_offset` dedup index
-    /// and was discarded without running the reducer.
-    Deduplicated,
 }
 
 impl ReducerOutcome {
     pub fn into_result(self) -> anyhow::Result<()> {
         match self {
-            Self::Committed | Self::Deduplicated => Ok(()),
+            Self::Committed => Ok(()),
             Self::Failed(e) => Err(anyhow::anyhow!(e)),
             Self::BudgetExceeded => Err(anyhow::anyhow!("reducer ran out of energy")),
         }
     }
 
     pub fn is_err(&self) -> bool {
-        !matches!(self, Self::Committed | Self::Deduplicated)
+        !matches!(self, Self::Committed)
     }
 }
 

crates/core/src/host/module_host.rs

@@ -589,7 +589,7 @@ pub fn call_identity_connected(
             // then insert into `st_client`,
             // but if we crashed in between, we'd be left in an inconsistent state
             // where the reducer had run but `st_client` was not yet updated.
-            ReducerOutcome::Committed | ReducerOutcome::Deduplicated => Ok(()),
+            ReducerOutcome::Committed => Ok(()),
 
             // If the reducer returned an error or couldn't run due to insufficient energy,
             // abort the connection: the module code has decided it doesn't want this client.
@@ -629,7 +629,8 @@ pub struct CallReducerParams {
     /// The tuple is `(sender_database_identity, sender_msg_id)`.
     /// Before running the reducer, `st_inbound_msg` is consulted:
     /// if `sender_msg_id` ≤ the stored last-delivered msg_id for the sender,
-    /// the call is a duplicate and returns [`ReducerCallError::Deduplicated`].
+    /// the call is a duplicate and returns the stored committed or failed result
+    /// without running the reducer again.
     /// Otherwise the reducer runs, and the stored msg_id is updated atomically
     /// within the same transaction.
     pub dedup_sender: Option<(Identity, u64)>,
@@ -1500,9 +1501,9 @@ impl ModuleHost {
                     ..
                 }) => fallback(),
 
-                // If it succeeded (or was deduplicated), as mentioned above, `st_client` is already updated.
+                // If it succeeded, as mentioned above, `st_client` is already updated.
                 Ok(ReducerCallResult {
-                    outcome: ReducerOutcome::Committed | ReducerOutcome::Deduplicated,
+                    outcome: ReducerOutcome::Committed,
                     ..
                 }) => Ok(()),
             }
@@ -1762,7 +1763,7 @@ impl ModuleHost {
     /// delivery using the `st_inbound_msg` dedup index.
     /// Before invoking the reducer, the receiver checks whether
     /// `sender_msg_id` ≤ the last delivered msg_id for `sender_database_identity`.
-    /// If so, the call is a duplicate and [`ReducerOutcome::Deduplicated`] is returned
+    /// If so, the call is a duplicate and the stored committed or failed result is returned
     /// without running the reducer.
     /// Otherwise the reducer runs, and the dedup index is updated atomically
     /// within the same transaction.

crates/core/src/host/wasm_common/module_host_actor.rs

@@ -487,6 +487,7 @@ impl<T: WasmInstance> WasmModuleInstance<T> {
         res
     }
 
+
     pub fn clear_all_clients(&self) -> anyhow::Result<()> {
         self.common.clear_all_clients()
     }
@@ -892,7 +893,15 @@ impl InstanceCommon {
                     s if s == st_inbound_msg_result_status::REDUCER_ERROR => {
                         ReducerOutcome::Failed(Box::new(stored.result_payload.into()))
                     }
-                    _ => ReducerOutcome::Deduplicated,
+                    _ => {
+                        log::warn!(
+                            "IDC: unexpected inbound dedup result_status={} for sender {}, msg_id={}",
+                            stored.result_status,
+                            sender_identity,
+                            sender_msg_id
+                        );
+                        ReducerOutcome::Committed
+                    }
                 };
                 return (
                     ReducerCallResult {