Implement POST /v1/swap/quote with capacity-aware simulation

Cargo.toml

@@ -25,6 +25,9 @@ clap = { version = "4.5.58", features = ["derive"] }
 reqwest = { version = "0.13.2", features = ["json"] }
 rain_orderbook_js_api = { path = "lib/rain.orderbook/crates/js_api", default-features = false }
 rain_orderbook_common = { path = "lib/rain.orderbook/crates/common", default-features = false }
+rain_orderbook_bindings = { path = "lib/rain.orderbook/crates/bindings", default-features = false }
+rain-math-float = { path = "lib/rain.orderbook/lib/rain.interpreter/lib/rain.interpreter.interface/lib/rain.math.float/crates/float" }
+async-trait = "0.1"
 wasm-bindgen = "=0.2.100"
 
 [dev-dependencies]

src/routes/swap/calldata.rs

@@ -0,0 +1,42 @@
+use crate::auth::AuthenticatedKey;
+use crate::error::{ApiError, ApiErrorResponse};
+use crate::fairings::{GlobalRateLimit, TracingSpan};
+use crate::types::swap::{SwapCalldataRequest, SwapCalldataResponse};
+use rocket::serde::json::Json;
+use rocket::State;
+use tracing::Instrument;
+
+#[utoipa::path(
+    post,
+    path = "/v1/swap/calldata",
+    tag = "Swap",
+    security(("basicAuth" = [])),
+    request_body = SwapCalldataRequest,
+    responses(
+        (status = 200, description = "Swap calldata", body = SwapCalldataResponse),
+        (status = 400, description = "Bad request", body = ApiErrorResponse),
+        (status = 401, description = "Unauthorized", body = ApiErrorResponse),
+        (status = 429, description = "Rate limited", body = ApiErrorResponse),
+        (status = 500, description = "Internal server error", body = ApiErrorResponse),
+    )
+)]
+#[post("/calldata", data = "<request>")]
+pub async fn post_swap_calldata(
+    _global: GlobalRateLimit,
+    _key: AuthenticatedKey,
+    shared_raindex: &State<crate::raindex::SharedRaindexProvider>,
+    span: TracingSpan,
+    request: Json<SwapCalldataRequest>,
+) -> Result<Json<SwapCalldataResponse>, ApiError> {
+    let req = request.into_inner();
+    async move {
+        tracing::info!(body = ?req, "request received");
+        let raindex = shared_raindex.read().await;
+        raindex
+            .run_with_client(move |_client| async move { todo!() })
+            .await
+            .map_err(ApiError::from)?
+    }
+    .instrument(span.0)
+    .await
+}

src/routes/swap/mod.rs

@@ -0,0 +1,118 @@
+mod calldata;
+mod quote;
+
+use crate::error::ApiError;
+use alloy::primitives::Address;
+use async_trait::async_trait;
+use rain_orderbook_common::raindex_client::orders::{
+    GetOrdersFilters, GetOrdersTokenFilter, RaindexOrder,
+};
+use rain_orderbook_common::raindex_client::RaindexClient;
+use rain_orderbook_common::take_orders::{
+    build_take_order_candidates_for_pair, TakeOrderCandidate,
+};
+use rocket::Route;
+
+#[async_trait(?Send)]
+pub(crate) trait SwapDataSource {
+    async fn get_orders_for_pair(
+        &self,
+        input_token: Address,
+        output_token: Address,
+    ) -> Result<Vec<RaindexOrder>, ApiError>;
+
+    async fn build_candidates_for_pair(
+        &self,
+        orders: &[RaindexOrder],
+        input_token: Address,
+        output_token: Address,
+    ) -> Result<Vec<TakeOrderCandidate>, ApiError>;
+}
+
+pub(crate) struct RaindexSwapDataSource<'a> {
+    pub client: &'a RaindexClient,
+}
+
+#[async_trait(?Send)]
+impl<'a> SwapDataSource for RaindexSwapDataSource<'a> {
+    async fn get_orders_for_pair(
+        &self,
+        input_token: Address,
+        output_token: Address,
+    ) -> Result<Vec<RaindexOrder>, ApiError> {
+        let filters = GetOrdersFilters {
+            active: Some(true),
+            tokens: Some(GetOrdersTokenFilter {
+                inputs: Some(vec![input_token]),
+                outputs: Some(vec![output_token]),
+            }),
+            ..Default::default()
+        };
+        self.client
+            .get_orders(None, Some(filters), None)
+            .await
+            .map_err(|e| {
+                tracing::error!(error = %e, "failed to query orders for pair");
+                ApiError::Internal("failed to query orders".into())
+            })
+    }
+
+    async fn build_candidates_for_pair(
+        &self,
+        orders: &[RaindexOrder],
+        input_token: Address,
+        output_token: Address,
+    ) -> Result<Vec<TakeOrderCandidate>, ApiError> {
+        build_take_order_candidates_for_pair(orders, input_token, output_token, None, None)
+            .await
+            .map_err(|e| {
+                tracing::error!(error = %e, "failed to build order candidates");
+                ApiError::Internal("failed to build order candidates".into())
+            })
+    }
+}
+
+pub use calldata::*;
+pub use quote::*;
+
+pub fn routes() -> Vec<Route> {
+    rocket::routes![quote::post_swap_quote, calldata::post_swap_calldata]
+}
+
+#[cfg(test)]
+pub(crate) mod test_fixtures {
+    use super::SwapDataSource;
+    use crate::error::ApiError;
+    use alloy::primitives::Address;
+    use async_trait::async_trait;
+    use rain_orderbook_common::raindex_client::orders::RaindexOrder;
+    use rain_orderbook_common::take_orders::TakeOrderCandidate;
+
+    pub struct MockSwapDataSource {
+        pub orders: Result<Vec<RaindexOrder>, ApiError>,
+        pub candidates: Vec<TakeOrderCandidate>,
+    }
+
+    #[async_trait(?Send)]
+    impl SwapDataSource for MockSwapDataSource {
+        async fn get_orders_for_pair(
+            &self,
+            _input_token: Address,
+            _output_token: Address,
+        ) -> Result<Vec<RaindexOrder>, ApiError> {
+            match &self.orders {
+                Ok(orders) => Ok(orders.clone()),
+                Err(_) => Err(ApiError::Internal("failed to query orders".into())),
+            }
+        }
+
+        async fn build_candidates_for_pair(
+            &self,
+            _orders: &[RaindexOrder],
+            _input_token: Address,
+            _output_token: Address,
+        ) -> Result<Vec<TakeOrderCandidate>, ApiError> {
+            Ok(self.candidates.clone())
+        }
+    }
+}