Notify banned solvers

crates/autopilot/src/domain/competition/participation_guard/db.rs

@@ -4,6 +4,7 @@ use {
         infra,
     },
     ethrpc::block_stream::CurrentBlockWatcher,
+    model::time::now_in_epoch_seconds,
     std::{
         collections::HashMap,
         sync::Arc,
@@ -84,17 +85,27 @@ impl Validator {
 
                         tracing::debug!(solvers = ?non_settling_solver_names, "found non-settling solvers");
 
-                        let now = Instant::now();
-                        non_settling_drivers
+                        let non_settling_drivers = non_settling_drivers
                             .into_iter()
                             // Check if solver accepted this feature. This should be removed once a CIP is
                             // approved.
-                            .filter_map(|driver| {
-                                driver.accepts_unsettled_blocking.then_some(driver.submission_address)
-                            })
-                            .for_each(|solver| {
-                                self_.0.banned_solvers.insert(solver, now);
-                            });
+                            .filter(|driver| driver.accepts_unsettled_blocking)
+                            .collect::<Vec<_>>();
+
+                        let now = Instant::now();
+                        let banned_until_timestamp =
+                            u64::from(now_in_epoch_seconds()) + self_.0.ttl.as_secs();
+                        infra::notify_non_settling_solvers(
+                            &non_settling_drivers,
+                            banned_until_timestamp,
+                        );
+
+                        for driver in non_settling_drivers {
+                            self_
+                                .0
+                                .banned_solvers
+                                .insert(driver.submission_address, now);
+                        }
                     }
                     Err(err) => {
                         tracing::warn!(?err, "error while searching for non-settling solvers")

crates/autopilot/src/domain/competition/participation_guard/mod.rs

@@ -2,11 +2,7 @@ mod db;
 mod onchain;
 
 use {
-    crate::{
-        arguments::DbBasedSolverParticipationGuardConfig,
-        domain::eth,
-        infra::{self, Ethereum},
-    },
+    crate::{arguments::DbBasedSolverParticipationGuardConfig, domain::eth, infra},
     std::{collections::HashMap, sync::Arc},
 };
 
@@ -22,7 +18,7 @@ struct Inner {
 
 impl SolverParticipationGuard {
     pub fn new(
-        eth: Ethereum,
+        eth: infra::Ethereum,
         persistence: infra::Persistence,
         competition_updates_receiver: tokio::sync::mpsc::UnboundedReceiver<()>,
         db_based_validator_config: DbBasedSolverParticipationGuardConfig,

crates/autopilot/src/domain/competition/participation_guard/onchain.rs

@@ -1,9 +1,9 @@
-use crate::{domain::eth, infra::Ethereum};
+use crate::{domain::eth, infra};
 
 /// Calls Authenticator contract to check if a solver has a sufficient
 /// permission.
 pub(super) struct Validator {
-    pub eth: Ethereum,
+    pub eth: infra::Ethereum,
 }
 
 #[async_trait::async_trait]

crates/autopilot/src/infra/mod.rs

@@ -7,5 +7,5 @@ pub use {
     blockchain::Ethereum,
     order_validation::banned,
     persistence::Persistence,
-    solvers::Driver,
+    solvers::{notify_non_settling_solvers, Driver},
 };

crates/autopilot/src/infra/solvers/dto/mod.rs

@@ -1,6 +1,7 @@
 //! Types for communicating with drivers as defined in
 //! `crates/driver/openapi.yml`.
 
+pub mod notify;
 pub mod reveal;
 pub mod settle;
 pub mod solve;

crates/autopilot/src/infra/solvers/dto/notify.rs

@@ -0,0 +1,18 @@
+use {serde::Serialize, serde_with::serde_as};
+
+#[serde_as]
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Request {
+    Banned {
+        reason: BanReason,
+        until_timestamp: u64,
+    },
+}
+
+#[serde_as]
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum BanReason {
+    UnsettledConsecutiveAuctions,
+}

crates/autopilot/src/infra/solvers/mod.rs

@@ -1,9 +1,10 @@
 use {
     self::dto::{reveal, settle, solve},
-    crate::{arguments::Account, domain::eth, util},
+    crate::{arguments::Account, domain::eth, infra::solvers::dto::notify, util},
     anyhow::{anyhow, Context, Result},
+    ethcontract::jsonrpc::futures_util::future::join_all,
     reqwest::{Client, StatusCode},
-    std::time::Duration,
+    std::{sync::Arc, time::Duration},
     thiserror::Error,
     url::Url,
 };
@@ -116,6 +117,10 @@ impl Driver {
         Ok(())
     }
 
+    pub async fn notify(&self, request: &notify::Request) -> Result<()> {
+        self.request_response("notify", request, None).await
+    }
+
     async fn request_response<Response>(
         &self,
         path: &str,
@@ -172,3 +177,29 @@ pub async fn response_body_with_size_limit(
     }
     Ok(bytes)
 }
+
+/// Try to notify all the non-settling solvers in a background task.
+pub fn notify_non_settling_solvers(
+    non_settling_drivers: &[Arc<Driver>],
+    banned_until_timestamp: u64,
+) {
+    let futures = non_settling_drivers
+        .iter()
+        .cloned()
+        .map(|driver| async move {
+            if let Err(err) = driver
+                .notify(&notify::Request::Banned {
+                    reason: notify::BanReason::UnsettledConsecutiveAuctions,
+                    until_timestamp: banned_until_timestamp,
+                })
+                .await
+            {
+                tracing::debug!(solver = ?driver.name, ?err, "unable to notify external solver");
+            }
+        })
+        .collect::<Vec<_>>();
+
+    tokio::spawn(async move {
+        join_all(futures).await;
+    });
+}

crates/driver/openapi.yml

@@ -138,6 +138,33 @@ paths:
           $ref: "#/components/responses/BadRequest"
         "500":
           $ref: "#/components/responses/InternalServerError"
+  /notify:
+    post:
+      description: |
+        Receive a notification in case the driver was banned for a certain reason.
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: string
+              enum:
+                - banned
+              description: |-
+                The reason for the notification with optional additional context.
+      responses:
+        "200":
+          description: notification successfully received.
+        "500":
+          description: Unable to notify solver.
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  error:
+                    type: string
+                    example: "Unable to notify solver"
 components:
   schemas:
     Address:

crates/driver/src/infra/api/error.rs

@@ -112,3 +112,12 @@ impl From<api::routes::OrderError> for (hyper::StatusCode, axum::Json<Error>) {
         error.into()
     }
 }
+
+impl From<api::routes::NotifyError> for (hyper::StatusCode, axum::Json<Error>) {
+    fn from(value: api::routes::NotifyError) -> Self {
+        let error = match value {
+            api::routes::NotifyError::UnableToNotify => Kind::Unknown,
+        };
+        error.into()
+    }
+}

crates/driver/src/infra/api/mod.rs

@@ -78,6 +78,7 @@ impl Api {
             let router = routes::solve(router);
             let router = routes::reveal(router);
             let router = routes::settle(router);
+            let router = routes::notify(router);
 
             let bad_token_config = solver.bad_token_detection();
             let mut bad_tokens =

crates/driver/src/infra/api/routes/mod.rs

@@ -1,6 +1,7 @@
 mod healthz;
 mod info;
 mod metrics;
+mod notify;
 mod quote;
 mod reveal;
 mod settle;
@@ -10,6 +11,7 @@ pub(super) use {
     healthz::healthz,
     info::info,
     metrics::metrics,
+    notify::{notify, NotifyError},
     quote::{quote, OrderError},
     reveal::reveal,
     settle::settle,

crates/driver/src/infra/api/routes/notify/dto/mod.rs

@@ -0,0 +1,3 @@
+mod notify_request;
+
+pub use notify_request::{Error as NotifyError, NotifyRequest};

crates/driver/src/infra/api/routes/notify/dto/notify_request.rs

@@ -0,0 +1,43 @@
+use {crate::infra::notify, serde::Deserialize, serde_with::serde_as};
+
+#[serde_as]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum NotifyRequest {
+    Banned {
+        reason: BanReason,
+        until_timestamp: u64,
+    },
+}
+
+#[serde_as]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum BanReason {
+    /// The driver won multiple consecutive auctions but never settled them.
+    UnsettledConsecutiveAuctions,
+}
+
+impl From<NotifyRequest> for notify::Kind {
+    fn from(value: NotifyRequest) -> Self {
+        match value {
+            NotifyRequest::Banned {
+                reason,
+                until_timestamp,
+            } => notify::Kind::Banned {
+                reason: match reason {
+                    BanReason::UnsettledConsecutiveAuctions => {
+                        notify::BanReason::UnsettledConsecutiveAuctions
+                    }
+                },
+                until_timestamp,
+            },
+        }
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("Unable to notify solver")]
+    UnableToNotify,
+}

crates/driver/src/infra/api/routes/notify/mod.rs

@@ -0,0 +1,23 @@
+mod dto;
+
+pub use dto::NotifyError;
+
+use crate::infra::api::{Error, State};
+
+pub(in crate::infra::api) fn notify(router: axum::Router<State>) -> axum::Router<State> {
+    router.route("/notify", axum::routing::post(route))
+}
+
+async fn route(
+    state: axum::extract::State<State>,
+    req: axum::Json<dto::NotifyRequest>,
+) -> Result<hyper::StatusCode, (hyper::StatusCode, axum::Json<Error>)> {
+    let solver = &state.solver().name().0;
+    tracing::debug!(?req, ?solver, "received a notification");
+    state
+        .solver()
+        .notify(None, None, req.0.into())
+        .await
+        .map(|_| hyper::StatusCode::OK)
+        .map_err(|_| NotifyError::UnableToNotify.into())
+}

crates/driver/src/infra/notify/mod.rs

@@ -5,18 +5,25 @@ use {
 
 mod notification;
 
-pub use notification::{Kind, Notification, ScoreKind, Settlement, SimulationSucceededAtLeastOnce};
+pub use notification::{
+    BanReason,
+    Kind,
+    Notification,
+    ScoreKind,
+    Settlement,
+    SimulationSucceededAtLeastOnce,
+};
 use {
     super::simulator,
     crate::domain::{eth, mempools::Error},
 };
 
 pub fn solver_timeout(solver: &Solver, auction_id: Option<auction::Id>) {
-    solver.notify(auction_id, None, notification::Kind::Timeout);
+    solver.notify_and_forget(auction_id, None, notification::Kind::Timeout);
 }
 
 pub fn empty_solution(solver: &Solver, auction_id: Option<auction::Id>, solution: solution::Id) {
-    solver.notify(
+    solver.notify_and_forget(
         auction_id,
         Some(solution),
         notification::Kind::EmptySolution,
@@ -45,7 +52,7 @@ pub fn scoring_failed(
         }
     };
 
-    solver.notify(auction_id, Some(solution_id.clone()), notification);
+    solver.notify_and_forget(auction_id, Some(solution_id.clone()), notification);
 }
 
 pub fn encoding_failed(
@@ -76,7 +83,7 @@ pub fn encoding_failed(
         solution::Error::Encoding(_) => return,
     };
 
-    solver.notify(auction_id, Some(solution_id.clone()), notification);
+    solver.notify_and_forget(auction_id, Some(solution_id.clone()), notification);
 }
 
 pub fn simulation_failed(
@@ -94,7 +101,7 @@ pub fn simulation_failed(
         ),
         simulator::Error::Other(error) => notification::Kind::DriverError(error.to_string()),
     };
-    solver.notify(auction_id, Some(solution_id.clone()), kind);
+    solver.notify_and_forget(auction_id, Some(solution_id.clone()), kind);
 }
 
 pub fn executed(
@@ -111,7 +118,7 @@ pub fn executed(
         Err(Error::Other(_) | Error::Disabled) => notification::Settlement::Fail,
     };
 
-    solver.notify(
+    solver.notify_and_forget(
         Some(auction_id),
         Some(solution_id.clone()),
         notification::Kind::Settled(kind),
@@ -123,13 +130,13 @@ pub fn duplicated_solution_id(
     auction_id: Option<auction::Id>,
     solution_id: &solution::Id,
 ) {
-    solver.notify(
+    solver.notify_and_forget(
         auction_id,
         Some(solution_id.clone()),
         notification::Kind::DuplicatedSolutionId,
     );
 }
 
 pub fn postprocessing_timed_out(solver: &Solver, auction_id: Option<auction::Id>) {
-    solver.notify(auction_id, None, notification::Kind::PostprocessingTimedOut);
+    solver.notify_and_forget(auction_id, None, notification::Kind::PostprocessingTimedOut);
 }