Autopilot Native Price API

crates/autopilot/Cargo.toml

@@ -17,6 +17,7 @@ path = "src/main.rs"
 [dependencies]
 alloy = { workspace = true, features = ["rand", "provider-debug-api", "provider-trace-api"] }
 app-data = { workspace = true }
+axum = { workspace = true }
 bytes-hex = { workspace = true } # may get marked as unused but it's used with serde
 anyhow = { workspace = true }
 async-trait = { workspace = true }
@@ -31,7 +32,8 @@ database = { workspace = true }
 derive_more = { workspace = true }
 ethrpc = { workspace = true }
 futures = { workspace = true }
-observe = { workspace = true }
+hyper = { workspace = true }
+observe = { workspace = true, features = ["axum-tracing"] }
 const-hex = { workspace = true }
 hex-literal = { workspace = true }
 humantime = { workspace = true }
@@ -58,6 +60,8 @@ sqlx = { workspace = true }
 strum = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "signal", "sync", "time"] }
+tower = { workspace = true }
+tower-http = { workspace = true, features = ["trace"] }
 tracing = { workspace = true }
 url = { workspace = true }
 web3 = { workspace = true }

crates/autopilot/openapi.yml

@@ -0,0 +1,94 @@
+openapi: 3.0.3
+info:
+  title: Autopilot Native Price API
+  description: |
+    Internal API for retrieving native token prices from the autopilot service.
+    This API is intended to be used by orderbook instances to query the shared
+    native price cache maintained by autopilot.
+  version: 0.0.1
+paths:
+  /native_price/{token}:
+    get:
+      operationId: getNativePrice
+      summary: Get the native price for a token
+      description: |
+        Returns the price of the specified token denominated in the native token
+        (e.g., ETH on Ethereum mainnet, xDAI on Gnosis Chain).
+      parameters:
+        - in: path
+          name: token
+          description: The address of the token to get the price for.
+          schema:
+            $ref: "#/components/schemas/Address"
+          required: true
+        - in: query
+          name: timeout_ms
+          description: |
+            Optional timeout in milliseconds for the price estimation request.
+            If not provided, uses the default timeout configured for autopilot.
+            Values below 250ms are automatically clamped to the minimum (250ms).
+            Values exceeding the configured maximum are clamped to the maximum.
+          schema:
+            type: integer
+            format: int64
+            minimum: 250
+            example: 5000
+          required: false
+      responses:
+        "200":
+          description: Native price retrieved successfully.
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/NativeTokenPrice"
+        "400":
+          description: |
+            Bad request. Possible causes:
+            - Unsupported token
+          content:
+            text/plain:
+              schema:
+                type: string
+                example: "Unsupported token"
+        "404":
+          description: No liquidity available for this token.
+          content:
+            text/plain:
+              schema:
+                type: string
+                example: "No liquidity"
+        "429":
+          description: Rate limited by upstream price estimator.
+          content:
+            text/plain:
+              schema:
+                type: string
+                example: "Rate limited"
+        "500":
+          description: Internal server error.
+          content:
+            text/plain:
+              schema:
+                type: string
+                example: "Internal error"
+components:
+  schemas:
+    Address:
+      description: |
+        An Ethereum address encoded as a hex with `0x` prefix.
+      type: string
+      example: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
+    NativeTokenPrice:
+      description: |
+        The price of a token denominated in the native token (e.g., ETH).
+      type: object
+      properties:
+        price:
+          type: number
+          format: double
+          description: |
+            The price of the token in terms of the native token. For example, if
+            1 USDC = 0.0005 ETH, the price would be 0.0005.
+          example: 0.0005
+      required:
+        - price

crates/autopilot/src/arguments.rs

@@ -59,6 +59,10 @@ pub struct Arguments {
     #[clap(long, env, default_value = "0.0.0.0:9589")]
     pub metrics_address: SocketAddr,
 
+    /// Address to bind the HTTP API server
+    #[clap(long, env, default_value = "0.0.0.0:12088")]
+    pub api_address: SocketAddr,
+
     /// Url of the Postgres database. By default connects to locally running
     /// postgres.
     #[clap(long, env, default_value = "postgresql://")]
@@ -370,6 +374,7 @@ impl std::fmt::Display for Arguments {
             ethflow_contracts,
             ethflow_indexing_start,
             metrics_address,
+            api_address,
             skip_event_sync,
             allowed_tokens,
             unsupported_tokens,
@@ -417,6 +422,7 @@ impl std::fmt::Display for Arguments {
         writeln!(f, "ethflow_contracts: {ethflow_contracts:?}")?;
         writeln!(f, "ethflow_indexing_start: {ethflow_indexing_start:?}")?;
         writeln!(f, "metrics_address: {metrics_address}")?;
+        writeln!(f, "api_address: {api_address}")?;
         display_secret_option(f, "db_write_url", Some(&db_write_url))?;
         writeln!(f, "skip_event_sync: {skip_event_sync}")?;
         writeln!(f, "allowed_tokens: {allowed_tokens:?}")?;

crates/autopilot/src/infra/api.rs

@@ -0,0 +1,133 @@
+use {
+    alloy::primitives::Address,
+    axum::{
+        Router,
+        extract::{Path, Query, State as AxumState},
+        http::StatusCode,
+        response::{IntoResponse, Json, Response},
+        routing::get,
+    },
+    model::quote::NativeTokenPrice,
+    observe::distributed_tracing::tracing_axum::{make_span, record_trace_id},
+    serde::Deserialize,
+    shared::price_estimation::{PriceEstimationError, native::NativePriceEstimating},
+    std::{
+        net::SocketAddr,
+        ops::RangeInclusive,
+        sync::Arc,
+        time::{Duration, Instant},
+    },
+    tokio::sync::oneshot,
+};
+
+/// Minimum allowed timeout for price estimation requests.
+/// Values below this are not useful as they don't give estimators enough time.
+const MIN_TIMEOUT: Duration = Duration::from_millis(250);
+
+#[derive(Clone)]
+struct State {
+    estimator: Arc<dyn NativePriceEstimating>,
+    allowed_timeout: RangeInclusive<Duration>,
+}
+
+#[derive(Debug, Deserialize)]
+struct NativePriceQuery {
+    /// Optional timeout in milliseconds for the price estimation request.
+    /// If not provided, uses the default timeout configured for autopilot.
+    /// Values below 250ms are automatically clamped to the minimum (250ms).
+    /// Values exceeding the configured maximum are clamped to the maximum.
+    #[serde(default)]
+    timeout_ms: Option<u64>,
+}
+
+pub async fn serve(
+    addr: SocketAddr,
+    estimator: Arc<dyn NativePriceEstimating>,
+    max_timeout: Duration,
+    shutdown: oneshot::Receiver<()>,
+) -> Result<(), hyper::Error> {
+    let state = State {
+        estimator,
+        allowed_timeout: MIN_TIMEOUT..=max_timeout,
+    };
+
+    let app = Router::new()
+        .route("/native_price/:token", get(get_native_price))
+        .with_state(state)
+        .layer(
+            tower::ServiceBuilder::new()
+                .layer(tower_http::trace::TraceLayer::new_for_http().make_span_with(make_span))
+                .map_request(record_trace_id),
+        );
+
+    let server = axum::Server::bind(&addr).serve(app.into_make_service());
+    tracing::info!(?addr, "serving HTTP API");
+
+    server
+        .with_graceful_shutdown(async {
+            shutdown.await.ok();
+        })
+        .await
+}
+
+async fn get_native_price(
+    Path(token): Path<Address>,
+    Query(query): Query<NativePriceQuery>,
+    AxumState(state): AxumState<State>,
+) -> Response {
+    let timeout = query
+        .timeout_ms
+        .map(Duration::from_millis)
+        .unwrap_or(*state.allowed_timeout.end())
+        .clamp(*state.allowed_timeout.start(), *state.allowed_timeout.end());
+
+    let start = Instant::now();
+    match state.estimator.estimate_native_price(token, timeout).await {
+        Ok(price) => {
+            let elapsed = start.elapsed();
+            tracing::debug!(
+                ?token,
+                ?timeout,
+                ?elapsed,
+                ?price,
+                "estimated native token price"
+            );
+            Json(NativeTokenPrice { price }).into_response()
+        }
+        Err(err) => {
+            let elapsed = start.elapsed();
+            tracing::warn!(
+                ?err,
+                ?token,
+                ?timeout,
+                ?elapsed,
+                "failed to estimate native token price"
+            );
+            error_to_response(err)
+        }
+    }
+}
+
+fn error_to_response(err: PriceEstimationError) -> Response {
+    match err {
+        PriceEstimationError::NoLiquidity | PriceEstimationError::EstimatorInternal(_) => {
+            (StatusCode::NOT_FOUND, "No liquidity").into_response()
+        }
+        PriceEstimationError::UnsupportedToken { token: _, reason } => (
+            StatusCode::BAD_REQUEST,
+            format!("Unsupported token, reason: {reason}"),
+        )
+            .into_response(),
+        PriceEstimationError::RateLimited => {
+            (StatusCode::TOO_MANY_REQUESTS, "Rate limited").into_response()
+        }
+        PriceEstimationError::UnsupportedOrderType(reason) => (
+            StatusCode::BAD_REQUEST,
+            format!("Unsupported order type, reason: {reason}"),
+        )
+            .into_response(),
+        PriceEstimationError::ProtocolInternal(_) => {
+            (StatusCode::INTERNAL_SERVER_ERROR, "Internal error").into_response()
+        }
+    }
+}

crates/autopilot/src/infra/mod.rs

@@ -1,3 +1,4 @@
+pub mod api;
 pub mod blockchain;
 pub mod persistence;
 pub mod shadow;

crates/autopilot/src/run.rs

@@ -533,6 +533,15 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
 
     let liveness = Arc::new(Liveness::new(args.max_auction_age));
     let startup = Arc::new(Some(AtomicBool::new(false)));
+
+    let (api_shutdown_sender, api_shutdown_receiver) = tokio::sync::oneshot::channel();
+    let api_task = tokio::spawn(infra::api::serve(
+        args.api_address,
+        native_price_estimator.clone(),
+        args.price_estimation.quote_timeout,
+        api_shutdown_receiver,
+    ));
+
     observe::metrics::serve_metrics(
         liveness.clone(),
         args.metrics_address,
@@ -699,6 +708,9 @@ pub async fn run(args: Arguments, shutdown_controller: ShutdownController) {
         competition_updates_sender,
     );
     run.run_forever(shutdown_controller).await;
+
+    api_shutdown_sender.send(()).ok();
+    api_task.await.ok();
 }
 
 async fn shadow_mode(args: Arguments) -> ! {

crates/e2e/src/setup/mod.rs

@@ -3,6 +3,7 @@ mod deploy;
 #[macro_use]
 pub mod onchain_components;
 pub mod fee;
+pub mod proxy;
 mod services;
 mod solver;