fix: server completes PUT operations even when client disconnects

This fixes the server-side root cause of issue #2278. Previously, when a client disconnected while a PUT operation was in progress, the `send_to_sender()` call would fail and propagate the error via `?`, causing the entire contract handler loop to exit. This broke all future contract operations for the node. The fix changes all `send_to_sender()` calls in the contract handler to use non-propagating error handling: if the response can't be delivered (e.g., because the client disconnected), we log at debug level and continue processing other events. The actual work (storing the contract, applying updates, etc.) has already been completed before the response is sent, so failing to deliver the response is not fatal. Changes: - contract/mod.rs: Change all `send_to_sender()?` to `if let Err(e) = send_to_sender() { log }` - contract/handler.rs: Add regression test verifying send_to_sender fails gracefully The client-side fix from the previous commit ensures fdev waits for the response, so the response delivery usually succeeds. This server-side fix ensures the node stays healthy even in edge cases where the client disconnects unexpectedly. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: sanity

crates/core/src/contract/handler.rs

@@ -664,6 +664,85 @@ pub mod test {
 
  Ok(())
  }
+
+ /// Regression test for issue #2278: Verifies that send_to_sender returns
+ /// an error when the response receiver is dropped, but does NOT crash or
+ /// break the channel.
+ ///
+ /// This tests that the channel infrastructure supports the fix in
+ /// contract/mod.rs where we changed `send_to_sender()?` to non-propagating
+ /// error handling, so the handler loop can continue even when a response
+ /// can't be delivered.
+ #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+ async fn send_to_sender_fails_gracefully_when_receiver_dropped() -> anyhow::Result<()> {
+ let (send_halve, mut rcv_halve, _) = contract_handler_channel();
+
+ let contract = ContractContainer::Wasm(ContractWasmAPIVersion::V1(WrappedContract::new(
+ Arc::new(ContractCode::from(vec![0, 1, 2, 3])),
+ Parameters::from(vec![4, 5]),
+ )));
+ let key = contract.key();
+
+ // Send a request
+ let h = GlobalExecutor::spawn({
+ async move {
+ send_halve
+ .send_to_handler(ContractHandlerEvent::PutQuery {
+ key,
+ state: vec![6, 7, 8].into(),
+ related_contracts: RelatedContracts::default(),
+ contract: None,
+ })
+ .await
+ }
+ });
+
+ // Receive the event from the handler side
+ let (id, ev) =
+ tokio::time::timeout(Duration::from_millis(100), rcv_halve.recv_from_sender())
+ .await??;
+
+ // Verify it's a PutQuery
+ let ContractHandlerEvent::PutQuery { state, .. } = ev else {
+ anyhow::bail!("expected PutQuery event");
+ };
+ assert_eq!(state.as_ref(), &[6, 7, 8]);
+
+ // Abort the request handler task - this drops the oneshot receiver
+ // simulating a client disconnect
+ h.abort();
+ // Wait a bit for the abort to take effect
+ tokio::time::sleep(Duration::from_millis(10)).await;
+
+ // Try to send the response - this should fail because the receiver was dropped
+ // when we aborted the task. In the actual contract_handling loop (after the fix),
+ // this would just log and continue rather than propagating the error.
+ let send_result = rcv_halve
+ .send_to_sender(
+ id,
+ ContractHandlerEvent::PutResponse {
+ new_value: Ok(vec![0, 7].into()),
+ },
+ )
+ .await;
+
+ // send_to_sender should fail because receiver was dropped
+ assert!(
+ send_result.is_err(),
+ "send_to_sender should fail when receiver is dropped, got {:?}",
+ send_result
+ );
+
+ // Verify the error is the expected NoEvHandlerResponse
+ // Use super:: to disambiguate from freenet_stdlib::prelude::ContractError
+ assert!(
+ matches!(send_result, Err(super::ContractError::NoEvHandlerResponse)),
+ "Expected NoEvHandlerResponse error, got {:?}",
+ send_result
+ );
+
+ Ok(())
+ }
 }
 
 pub(super) mod in_memory {

crates/core/src/contract/mod.rs

@@ -55,7 +55,8 @@ where
  phase = "get_complete",
  "Fetched contract"
  );
- contract_handler
+ // Send response back to caller. If the caller disconnected, just log and continue.
+ if let Err(error) = contract_handler
  .channel()
  .send_to_sender(
  id,
@@ -65,13 +66,13 @@ where
  },
  )
  .await
-  .map_err(|error| {
-  tracing::debug!(
-  error = %error,
-  "Shutting down contract handler"
- );
-  error
-  })?;
+ {
+ tracing::debug!(
+ error = %error,
+ contract = %key,
+ "Failed to send GET response (client may have disconnected)"
+ );
+ }
  }
  Err(err) => {
  tracing::warn!(
@@ -89,7 +90,8 @@ where
  );
  return Err(ContractError::FatalExecutorError { key, error: err });
  }
- contract_handler
+ // Send error response back to caller. If the caller disconnected, just log and continue.
+ if let Err(error) = contract_handler
  .channel()
  .send_to_sender(
  id,
@@ -99,13 +101,13 @@ where
  },
  )
  .await
-  .map_err(|error| {
-  tracing::debug!(
-  error = %error,
-  "Shutting down contract handler"
- );
-  error
-  })?;
+ {
+ tracing::debug!(
+ error = %error,
+ contract = %key,
+ "Failed to send GET error response (client may have disconnected)"
+ );
+ }
  }
  }
  }
@@ -168,17 +170,20 @@ where
  }
  };
 
- contract_handler
+ // Send response back to caller. If the caller disconnected (e.g., WebSocket closed),
+ // the response channel may be dropped. This is not fatal - the contract has already
+ // been stored, so we just log and continue processing other events.
+ if let Err(error) = contract_handler
  .channel()
  .send_to_sender(id, event_result)
  .await
-  .map_err(|error| {
-  tracing::debug!(
-  error = %error,
-  "Shutting down contract handler"
- );
-  error
-  })?;
+ {
+ tracing::debug!(
+ error = %error,
+ contract = %key,
+ "Failed to send PUT response (client may have disconnected)"
+ );
+ }
  }
  ContractHandlerEvent::UpdateQuery {
  key,
@@ -258,17 +263,19 @@ where
  }
  };
 
- contract_handler
+ // Send response back to caller. If the caller disconnected, the response channel
+ // may be dropped. This is not fatal - the update has already been applied.
+ if let Err(error) = contract_handler
  .channel()
  .send_to_sender(id, event_result)
  .await
-  .map_err(|error| {
-  tracing::debug!(
-  error = %error,
-  "Shutting down contract handler"
- );
-  error
-  })?;
+ {
+ tracing::debug!(
+ error = %error,
+ contract = %key,
+ "Failed to send UPDATE response (client may have disconnected)"
+ );
+ }
  }
  ContractHandlerEvent::DelegateRequest {
  req,
@@ -309,17 +316,19 @@ where
  }
  };
 
- contract_handler
+ // Send response back to caller. If the caller disconnected, the response channel
+ // may be dropped. This is not fatal - the delegate has already been processed.
+ if let Err(error) = contract_handler
  .channel()
  .send_to_sender(id, ContractHandlerEvent::DelegateResponse(response))
  .await
-  .map_err(|error| {
-  tracing::debug!(
-  error = %error,
-  "Shutting down contract handler"
- );
-  error
-  })?;
+ {
+ tracing::debug!(
+ error = %error,
+ delegate_key = %delegate_key,
+ "Failed to send DELEGATE response (client may have disconnected)"
+ );
+ }
  }
  ContractHandlerEvent::RegisterSubscriberListener {
  key,
@@ -340,14 +349,19 @@ where
  );
  });
 
- // FIXME: if there is an error senc actually an error back
- contract_handler
+ // FIXME: if there is an error send actually an error back
+ // If the caller disconnected, just log and continue.
+ if let Err(error) = contract_handler
  .channel()
  .send_to_sender(id, ContractHandlerEvent::RegisterSubscriberListenerResponse)
  .await
- .inspect_err(|error| {
- tracing::debug!(%error, "shutting down contract handler");
- })?;
+ {
+ tracing::debug!(
+ error = %error,
+ contract = %key,
+ "Failed to send RegisterSubscriberListener response (client may have disconnected)"
+ );
+ }
  }
  ContractHandlerEvent::QuerySubscriptions { callback } => {
  // Get subscription information from the executor and send it through the callback
@@ -362,13 +376,17 @@ where
  .send(crate::message::QueryResult::NetworkDebug(network_debug))
  .await;
 
- contract_handler
+ // If the caller disconnected, just log and continue.
+ if let Err(error) = contract_handler
  .channel()
  .send_to_sender(id, ContractHandlerEvent::QuerySubscriptionsResponse)
  .await
- .inspect_err(|error| {
- tracing::debug!(%error, "shutting down contract handler");
- })?;
+ {
+ tracing::debug!(
+ error = %error,
+ "Failed to send QuerySubscriptions response (client may have disconnected)"
+ );
+ }
  }
  _ => unreachable!("ContractHandlerEvent enum should be exhaustive here"),
  }