feat(autopilot-svm) PR10: binary wiring and liveness

crates/autopilot-svm/Cargo.toml

@@ -4,29 +4,45 @@ version = "0.1.0"
 edition = "2024"
 description = "Solana autopilot: the chain-generic auction loop and its seam traits"
 
+[lib]
+name = "autopilot_svm"
+path = "src/lib.rs"
+
+[[bin]]
+name = "autopilot-svm"
+path = "src/main.rs"
+
 [dependencies]
 anyhow = { workspace = true }
 async-trait = { workspace = true }
+axum = { workspace = true }
 bigdecimal = { workspace = true }
 chain-types = { workspace = true }
 chrono = { workspace = true, features = ["serde"] }
+clap = { workspace = true }
+configs = { workspace = true }
 const-hex = { workspace = true }
 cow-solana-rpc = { workspace = true }
 database = { workspace = true }
 futures = { workspace = true }
+humantime-serde = { workspace = true }
+observe = { workspace = true }
 reqwest = { workspace = true, features = ["json"] }
 serde = { workspace = true }
+serde-ext = { workspace = true }
 serde_json = { workspace = true }
 serde_with = { workspace = true }
+solana-sdk = { workspace = true }
 sqlx = { workspace = true }
 thiserror = { workspace = true }
+tikv-jemallocator = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time"] }
+toml = { workspace = true }
 tracing = { workspace = true }
 url = { workspace = true }
 winner-selection = { workspace = true }
 
 [dev-dependencies]
-axum = { workspace = true }
 
 [lints]
 workspace = true

crates/autopilot-svm/example.toml

@@ -0,0 +1,32 @@
+# Example configuration for the Solana autopilot.
+
+# Serves /metrics, /liveness, /ready, and /startup.
+metrics-port = 9586
+# The pod fails the liveness probe when no auction cycle completed in this
+# time.
+max-auction-age = "5m"
+
+[database]
+# The Postgres database the indexer writes to. A value like "%DB_WRITE_URL"
+# reads the URL from that environment variable.
+write-url = "postgresql://"
+
+[rpc]
+# The devnet node.
+endpoint = "https://api.devnet.solana.com"
+request-timeout = "10s"
+
+[contracts]
+wrapped-native-mint = "So11111111111111111111111111111111111111112"
+
+[competition]
+max-winners = 1
+solve-deadline = "6s"
+submission-deadline-slots = 25
+
+[[drivers]]
+name = "baseline"
+url = "http://localhost:11088"
+
+[logging]
+filter = "info,autopilot_svm=debug"

crates/autopilot-svm/src/domain/cycle.rs

@@ -20,6 +20,10 @@ impl Cycle for SolanaCycle {
     type Solution = Solution;
     /// The chain progress marker is the slot.
     type Tip = u64;
+
+    fn submission_deadline(tip: &u64, allowance: u64) -> u64 {
+        tip + allowance
+    }
 }
 
 /// One driver's solution, attributed to the driver that proposed it so the

crates/autopilot-svm/src/infra/config.rs

@@ -0,0 +1,161 @@
+//! Configuration of the autopilot's endpoints and competition parameters.
+
+use {
+    configs::{database::DatabasePoolConfig, shared::LoggingConfig},
+    serde::Deserialize,
+    serde_ext::{deserialize_nonempty_vec, deserialize_solana_pubkey_b58},
+    solana_sdk::pubkey::Pubkey,
+    std::{num::NonZero, path::Path, time::Duration},
+    tokio::fs,
+};
+
+/// Load the autopilot configuration from a TOML file.
+///
+/// # Panics
+///
+/// This function panics if the config is invalid or on I/O errors.
+pub async fn load(path: &Path) -> Config {
+    let data = fs::read_to_string(path)
+        .await
+        .unwrap_or_else(|e| panic!("I/O error while reading {path:?}: {e:?}"));
+
+    toml::de::from_str(&data).unwrap_or_else(|err| {
+        if std::env::var("TOML_TRACE_ERROR").is_ok_and(|v| v == "1") {
+            panic!("failed to parse TOML config at {path:?}: {err:#?}")
+        } else {
+            panic!(
+                "failed to parse TOML config at: {path:?}. Set TOML_TRACE_ERROR=1 to print \
+                 parsing error but this may leak secrets."
+            )
+        }
+    })
+}
+
+/// Configuration of the autopilot's endpoints and competition parameters.
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct Config {
+    /// Connection configuration for the database the indexer writes to.
+    #[serde(default)]
+    pub database: DatabasePoolConfig,
+    /// JSON-RPC client configuration.
+    pub rpc: Rpc,
+    /// On-chain addresses the autopilot reads.
+    pub contracts: Contracts,
+    /// Competition parameters.
+    #[serde(default)]
+    pub competition: Competition,
+    /// Port the metrics and probes server binds to, on every interface.
+    #[serde(default = "default_metrics_port")]
+    pub metrics_port: u16,
+    /// If no auction cycle completed in this time the pod fails the liveness
+    /// check.
+    #[serde(with = "humantime_serde", default = "default_max_auction_age")]
+    pub max_auction_age: Duration,
+    /// The driver endpoints participating in every auction.
+    #[serde(deserialize_with = "deserialize_nonempty_vec")]
+    pub drivers: Vec<Driver>,
+    /// Logging configuration.
+    #[serde(default)]
+    pub logging: LoggingConfig,
+}
+
+impl Config {
+    /// Build the `observe::Config` for the tracing framework from the logging
+    /// configuration.
+    pub fn observe_config(&self) -> observe::Config {
+        observe::Config::new(
+            &self.logging.filter,
+            self.logging.stderr_threshold,
+            self.logging.use_json,
+            None,
+        )
+    }
+}
+
+const fn default_metrics_port() -> u16 {
+    observe::metrics::DEFAULT_METRICS_PORT
+}
+
+const fn default_max_auction_age() -> Duration {
+    Duration::from_mins(5)
+}
+
+/// JSON-RPC client configuration.
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct Rpc {
+    /// HTTP endpoint of the Solana JSON-RPC node.
+    pub endpoint: url::Url,
+    /// Timeout for a single RPC request.
+    #[serde(with = "humantime_serde")]
+    pub request_timeout: Duration,
+}
+
+/// On-chain addresses: programs and mints.
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct Contracts {
+    /// The wrapped native token mint (wSOL), the unit scores are denominated
+    /// in.
+    #[serde(deserialize_with = "deserialize_solana_pubkey_b58")]
+    pub wrapped_native_mint: Pubkey,
+}
+
+/// Competition parameters.
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields, default)]
+pub struct Competition {
+    /// Maximum number of winning solutions per auction.
+    pub max_winners: NonZero<usize>,
+    /// How long drivers get to answer `/solve`.
+    #[serde(with = "humantime_serde")]
+    pub solve_deadline: Duration,
+    /// Slots a settlement may take after ranking before it counts as late.
+    pub submission_deadline_slots: NonZero<u64>,
+}
+
+impl Default for Competition {
+    fn default() -> Self {
+        Self {
+            max_winners: NonZero::new(1).expect("non-zero literal"),
+            // The EVM fast chains run 6s solve deadlines.
+            solve_deadline: Duration::from_secs(6),
+            submission_deadline_slots: NonZero::new(25).expect("non-zero literal"),
+        }
+    }
+}
+
+/// One driver endpoint.
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+pub struct Driver {
+    /// Name for logs and metrics.
+    pub name: String,
+    /// HTTP endpoint of the driver API.
+    pub url: url::Url,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn loads_the_example_config() {
+        let config = load(std::path::Path::new("example.toml")).await;
+        assert_eq!(config.database.write_url.as_str(), "postgresql://");
+        assert_eq!(
+            config.contracts.wrapped_native_mint,
+            "So11111111111111111111111111111111111111112"
+                .parse()
+                .unwrap()
+        );
+        assert_eq!(config.competition.max_winners.get(), 1);
+        assert_eq!(config.competition.solve_deadline, Duration::from_secs(6));
+        assert_eq!(config.competition.submission_deadline_slots.get(), 25);
+        assert_eq!(config.max_auction_age, Duration::from_secs(5 * 60));
+        assert_eq!(config.drivers.len(), 1);
+        assert_eq!(config.drivers[0].name, "baseline");
+        assert_eq!(config.logging.filter, "info,autopilot_svm=debug");
+    }
+}

crates/autopilot-svm/src/infra/db.rs

@@ -9,6 +9,9 @@ use {
     sqlx::PgExecutor,
 };
 
+/// The channel the schema's `solana.settlements` trigger notifies.
+pub const SETTLEMENT_FINALIZED_CHANNEL: &str = "solana_settlement_finalized";
+
 /// The `solana.orders` columns auction assembly reads.
 #[derive(Clone, Debug, sqlx::FromRow)]
 pub struct OrderRow {

crates/autopilot-svm/src/infra/executor.rs

@@ -13,10 +13,6 @@ use {
     std::sync::Arc,
 };
 
-/// Slots a settlement may take after ranking before it counts as late.
-/// TODO: make configurable.
-const SUBMISSION_DEADLINE_SLOTS: u64 = 25;
-
 /// Sends `/settle` to each winner's driver. Submission runs detached, the
 /// loop starts the next cycle while settlements land.
 pub struct DriverExecutor {
@@ -34,11 +30,7 @@ impl DriverExecutor {
 
 #[async_trait]
 impl SettlementExecutor<SolanaCycle> for DriverExecutor {
-    fn submission_deadline(&self, tip: &u64) -> u64 {
-        tip + SUBMISSION_DEADLINE_SLOTS
-    }
-
-    async fn execute(&self, auction_id: i64, ranking: &Ranking, deadline: u64) {
+    async fn execute(&self, auction_id: i64, ranking: &Ranking, tip: &u64, deadline: u64) {
         for winner in ranking.inner.winners() {
             let key = (winner.solver(), winner.id());
             let Some(driver) = ranking
@@ -59,13 +51,7 @@ impl SettlementExecutor<SolanaCycle> for DriverExecutor {
             // the dispatch is the priority.
             if let Err(err) = self
                 .windows
-                .open_dispatched(
-                    auction_id,
-                    winner.solver(),
-                    winner.id(),
-                    deadline.saturating_sub(SUBMISSION_DEADLINE_SLOTS),
-                    deadline,
-                )
+                .open_dispatched(auction_id, winner.solver(), winner.id(), *tip, deadline)
                 .await
             {
                 tracing::error!(auction_id, ?err, "failed to open the settlement window");

crates/autopilot-svm/src/infra/mod.rs

@@ -1,6 +1,7 @@
 //! Infrastructure: database access, driver clients, and the loop seams.
 
 pub mod competition;
+pub mod config;
 pub mod db;
 pub mod driver;
 pub mod executor;

crates/autopilot-svm/src/infra/observation.rs

@@ -116,7 +116,7 @@ impl NotifyHandler for SettlementWindows {
 mod tests {
     use {
         super::SettlementWindows,
-        crate::infra::listen::ListenSession,
+        crate::infra::{db, listen::ListenSession},
         chain_types::solana::Pubkey,
         sqlx::PgPool,
         std::time::Duration,
@@ -160,8 +160,11 @@ VALUES (10, $1, 0, $2, $3, NULL)
             .await
             .unwrap();
 
-        let task =
-            ListenSession::spawn(pool.clone(), "solana_settlement_finalized", windows.clone());
+        let task = ListenSession::spawn(
+            pool.clone(),
+            db::SETTLEMENT_FINALIZED_CHANNEL,
+            windows.clone(),
+        );
 
         insert_settlement(&pool, 4242).await;
 

crates/autopilot-svm/src/lib.rs

@@ -1,7 +1,6 @@
 //! Solana-side autopilot components built on a chain-generic auction loop.
 
-#![expect(dead_code, reason = "consumed by the binary wiring")]
-
+pub mod run;
 pub mod run_loop;
 
 mod domain;

crates/autopilot-svm/src/main.rs

@@ -0,0 +1,7 @@
+#[global_allocator]
+static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
+
+#[tokio::main]
+async fn main() {
+    autopilot_svm::run::start(std::env::args()).await;
+}