Notify banned solvers

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

@@ -3,6 +3,7 @@ use {
         domain::{eth, Metrics},
         infra,
     },
+    chrono::Utc,
     ethrpc::block_stream::CurrentBlockWatcher,
     std::{
         collections::HashMap,
@@ -72,6 +73,7 @@ impl Validator {
                 };
 
                 let now = Instant::now();
+                let banned_until = Utc::now() + self_.0.ttl;
                 let non_settling_solver_names: Vec<&str> = non_settling_solvers
                     .iter()
                     .filter_map(|solver| self_.0.drivers_by_address.get(solver))
@@ -83,6 +85,7 @@ impl Validator {
                         // CIP making this mandatory has been approved.
                         if driver.requested_timeout_on_problems {
                             tracing::debug!(solver = ?driver.name, "disabling solver temporarily");
+                            infra::notify_non_settling_solver(driver.clone(), banned_until);
                             self_
                                 .0
                                 .banned_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::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_solver, 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,22 @@
+use {
+    chrono::{DateTime, Utc},
+    serde::Serialize,
+    serde_with::serde_as,
+};
+
+#[serde_as]
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Request {
+    Banned {
+        reason: BanReason,
+        until: DateTime<Utc>,
+    },
+}
+
+#[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},
+    chrono::{DateTime, Utc},
     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,15 @@ pub async fn response_body_with_size_limit(
     }
     Ok(bytes)
 }
+
+/// Notifies the non-settling driver in a fire-and-forget manner.
+pub fn notify_non_settling_solver(non_settling_driver: Arc<Driver>, banned_until: DateTime<Utc>) {
+    tokio::spawn(async move {
+        let _ = non_settling_driver
+            .notify(&notify::Request::Banned {
+                reason: notify::BanReason::UnsettledConsecutiveAuctions,
+                until: banned_until,
+            })
+            .await;
+    });
+}

crates/driver/openapi.yml

@@ -138,6 +138,23 @@ paths:
           $ref: "#/components/responses/BadRequest"
         "500":
           $ref: "#/components/responses/InternalServerError"
+  /notify:
+    post:
+      description: |
+        Receive a notification with a specific 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.
 components:
   schemas:
     Address:

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,
     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::NotifyRequest;

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

@@ -0,0 +1,39 @@
+use {
+    crate::infra::notify,
+    chrono::{DateTime, Utc},
+    serde::Deserialize,
+    serde_with::serde_as,
+};
+
+#[serde_as]
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum NotifyRequest {
+    Banned {
+        reason: BanReason,
+        until: DateTime<Utc>,
+    },
+}
+
+#[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 } => notify::Kind::Banned {
+                reason: match reason {
+                    BanReason::UnsettledConsecutiveAuctions => {
+                        notify::BanReason::UnsettledConsecutiveAuctions
+                    }
+                },
+                until,
+            },
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+mod dto;
+
+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());
+    Ok(hyper::StatusCode::OK)
+}

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

@@ -5,7 +5,14 @@ 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},

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

@@ -3,6 +3,7 @@ use {
         competition::{auction, solution},
         eth::{self, Ether, TokenAddress},
     },
+    chrono::{DateTime, Utc},
     std::collections::BTreeSet,
 };
 
@@ -45,6 +46,11 @@ pub enum Kind {
     DriverError(String),
     /// On-chain solution postprocessing timed out.
     PostprocessingTimedOut,
+    /// The solver has been banned for a specific reason.
+    Banned {
+        reason: BanReason,
+        until: DateTime<Utc>,
+    },
 }
 
 #[derive(Debug)]
@@ -58,6 +64,12 @@ pub enum ScoreKind {
     MissingPrice(TokenAddress),
 }
 
+#[derive(Debug)]
+pub enum BanReason {
+    /// The driver won multiple consecutive auctions but never settled them.
+    UnsettledConsecutiveAuctions,
+}
+
 #[derive(Debug)]
 pub enum Settlement {
     /// Winning solver settled successfully transaction onchain.

crates/driver/src/infra/solver/dto/notification.rs

@@ -7,6 +7,7 @@ use {
         infra::notify,
         util::serialize,
     },
+    chrono::{DateTime, Utc},
     serde::Serialize,
     serde_with::serde_as,
     std::collections::BTreeSet,
@@ -61,6 +62,14 @@ impl Notification {
                     notify::Settlement::Expired => Kind::Expired,
                 },
                 notify::Kind::PostprocessingTimedOut => Kind::PostprocessingTimedOut,
+                notify::Kind::Banned { reason, until } => Kind::Banned {
+                    reason: match reason {
+                        notify::BanReason::UnsettledConsecutiveAuctions => {
+                            BanReason::UnsettledConsecutiveAuctions
+                        }
+                    },
+                    until,
+                },
             },
         }
     }
@@ -144,6 +153,16 @@ pub enum Kind {
     Expired,
     Fail,
     PostprocessingTimedOut,
+    Banned {
+        reason: BanReason,
+        until: DateTime<Utc>,
+    },
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase", tag = "reason")]
+pub enum BanReason {
+    UnsettledConsecutiveAuctions,
 }
 
 type BlockNo = u64;

crates/solvers/openapi.yml

@@ -89,6 +89,7 @@ paths:
                     - cancelled
                     - fail
                     - postprocessingTimedOut
+                    - banned
       responses:
         "200":
           description: notification successfully received.