Add v1/orders POST endpoint to get orders in batches

crates/database/src/jit_orders.rs

@@ -54,6 +54,16 @@ SELECT,
     sqlx::query_as(QUERY).bind(uid).fetch_optional(ex).await
 }
 
+#[instrument(skip_all)]
+pub async fn get_many_by_uid<'a>(
+    ex: &'a mut PgConnection,
+    order_uids: &'a [OrderUid],
+) -> Result<Vec<orders::FullOrder>, sqlx::Error> {
+    const QUERY: &str =
+        const_format::concatcp!("SELECT ", SELECT, " FROM ", FROM, " WHERE o.uid = ANY($1)");
+    sqlx::query_as(QUERY).bind(order_uids).fetch_all(ex).await
+}
+
 #[instrument(skip_all)]
 pub async fn get_by_tx(
     ex: &mut PgConnection,

crates/database/src/orders.rs

@@ -644,6 +644,21 @@ COALESCE((SELECT executed_fee_token FROM order_execution oe WHERE oe.order_uid =
 "#;
 
 pub const FROM: &str = "orders o";
+const FULL_ORDER_WITH_QUOTE: &str = const_format::concatcp!(
+    "SELECT ",
+    SELECT,
+    ", o_quotes.sell_amount as quote_sell_amount",
+    ", o_quotes.buy_amount as quote_buy_amount",
+    ", o_quotes.gas_amount as quote_gas_amount",
+    ", o_quotes.gas_price as quote_gas_price",
+    ", o_quotes.sell_token_price as quote_sell_token_price",
+    ", o_quotes.verified as quote_verified",
+    ", o_quotes.metadata as quote_metadata",
+    ", o_quotes.solver as solver",
+    " FROM ",
+    FROM,
+    " LEFT JOIN order_quotes o_quotes ON o.uid = o_quotes.order_uid",
+);
 
 #[instrument(skip_all)]
 pub async fn single_full_order_with_quote(
@@ -652,22 +667,21 @@ pub async fn single_full_order_with_quote(
 ) -> Result<Option<FullOrderWithQuote>, sqlx::Error> {
     #[rustfmt::skip]
     const QUERY: &str = const_format::concatcp!(
-        "SELECT ", SELECT,
-        ", o_quotes.sell_amount as quote_sell_amount",
-        ", o_quotes.buy_amount as quote_buy_amount",
-        ", o_quotes.gas_amount as quote_gas_amount",
-        ", o_quotes.gas_price as quote_gas_price",
-        ", o_quotes.sell_token_price as quote_sell_token_price",
-        ", o_quotes.verified as quote_verified",
-        ", o_quotes.metadata as quote_metadata",
-        ", o_quotes.solver as solver",
-        " FROM ", FROM,
-        " LEFT JOIN order_quotes o_quotes ON o.uid = o_quotes.order_uid",
-        " WHERE o.uid = $1",
-        );
+        FULL_ORDER_WITH_QUOTE,
+        " WHERE o.uid = $1"
+    );
     sqlx::query_as(QUERY).bind(uid).fetch_optional(ex).await
 }
 
+#[instrument(skip_all)]
+pub async fn many_full_orders_with_quotes<'a>(
+    ex: &'a mut PgConnection,
+    order_ids: &'a [OrderUid],
+) -> Result<Vec<FullOrderWithQuote>, sqlx::Error> {
+    const QUERY: &str = const_format::concatcp!(FULL_ORDER_WITH_QUOTE, " WHERE o.uid = ANY($1)");
+    sqlx::query_as(QUERY).bind(order_ids).fetch_all(ex).await
+}
+
 // Partial query for getting the log indices of events of a single settlement.
 //
 // This will fail if we ever have multiple settlements in the same transaction

crates/e2e/tests/e2e/malformed_requests.rs

@@ -3,6 +3,7 @@
 
 use {
     e2e::setup::{API_HOST, OnchainComponents, Services, run_test},
+    model::order::{ORDER_UID_LIMIT, OrderUid},
     orderbook::api::Error,
     reqwest::StatusCode,
     serde_json::json,
@@ -306,4 +307,30 @@ async fn http_validation(web3: Web3) {
         !error.description.is_empty(),
         "Error response should have non-empty 'description' field"
     );
+
+    // /api/v1/orders/by_uids requires Json body
+    let response = client
+        .post(format!("{API_HOST}/api/v1/orders/by_uids"))
+        .header("Content-Type", "application/json")
+        .body("Not json")
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+
+    // Querying for more than ORDER_UID_LIMIT orders should fail
+    let response = client
+        .post(format!("{API_HOST}/api/v1/orders/by_uids"))
+        .header("Content-Type", "application/json")
+        .json(&json!(
+            (0..ORDER_UID_LIMIT + 1)
+                .map(|_| OrderUid::default())
+                .collect::<Vec<_>>()
+        ))
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
 }

crates/model/src/order.rs

@@ -731,7 +731,9 @@ pub struct OrderMetadata {
     pub quote: Option<OrderQuote>,
 }
 
-pub const ORDER_UID_LIMIT: usize = 1024;
+/// OrderUid is 56 bytes. When hex encoded as 0x prefixes Json string it is 116.
+/// Chosen to be under the MAX_JSON_BODY_PAYLOAD size of 1024 * 16
+pub const ORDER_UID_LIMIT: usize = 128;
 
 // uid as 56 bytes: 32 for orderDigest, 20 for ownerAddress and 4 for validTo
 #[derive(Clone, Copy, Eq, Hash, PartialEq, PartialOrd, Ord)]

crates/orderbook/openapi.yml

@@ -129,6 +129,60 @@ paths:
           description: One or more orders were not found and no orders were cancelled.
         "422":
           description: Unable to parse request body as valid JSON.
+  "/api/v1/orders/by_uids":
+    post:
+      operationId: getOrders
+      summary: Get existing orders from the list of UIDs.
+      description: |
+        Returns an array where each element is an object with either
+        an "order" key containing the full order, or an "error" key
+        containing the UID and a description of what went wrong.
+      requestBody:
+        description: The list of up to 128 order uids to fetch
+        required: true
+        content:
+          application/json:
+            schema:
+              type: array
+              items:
+                $ref: "#/components/schemas/UID"
+      responses:
+        "200":
+          description: |
+            The resulting full order data based on the request. Each element of the array is
+            an object of the following format:
+            - `{"order": <Order>}` for successfully fetched orders
+            - `{"error": {"uid": "<UID>", "description": "<message>"}}` for orders that failed conversion
+            The result ordering is not guaranteed and might differ from the order of requested UIDs.
+            Orders that do not exist in the database will be missing from the response.
+          content:
+            application/json:
+              schema:
+                oneOf:
+                  - type: object
+                    properties:
+                      order:
+                        $ref: "#/components/schemas/Order"
+                    required:
+                      - order
+                  - type: object
+                    properties:
+                      error:
+                        type: object
+                        properties:
+                          uid:
+                            $ref: "#/components/schemas/UID"
+                          description:
+                            type: string
+                        required:
+                          - uid
+                          - description
+                    required:
+                      - error
+        "400":
+          description: Request array size larger than 128 or unable to parse request body as valid JSON.
+        "422":
+          description: Could not decode array values as order UID.
   "/api/v1/orders/{UID}":
     get:
       operationId: getOrder
@@ -1510,7 +1564,7 @@ components:
       properties:
         orderUids:
           type: array
-          description: UIDs of orders to cancel.
+          description: Up to 128 UIDs of orders to cancel.
           items:
             $ref: "#/components/schemas/UID"
         signature:

crates/orderbook/src/api.rs

@@ -35,6 +35,7 @@ mod get_native_price;
 mod get_order_by_uid;
 mod get_order_status;
 mod get_orders_by_tx;
+mod get_orders_by_uid;
 mod get_solver_competition;
 mod get_solver_competition_v2;
 mod get_token_metadata;
@@ -190,6 +191,11 @@ pub fn handle_all_routes(
             "/api/v1/orders",
             post(post_order::post_order_handler),
         ),
+        (
+            "POST",
+            "/api/v1/orders/by_uids",
+            post(get_orders_by_uid::get_orders_by_uid_handler),
+        ),
         (
             "DELETE",
             "/api/v1/orders",

crates/orderbook/src/api/get_orders_by_uid.rs

@@ -0,0 +1,122 @@
+use {
+    crate::api::AppState,
+    anyhow::Result,
+    axum::{
+        extract::State,
+        http::StatusCode,
+        response::{IntoResponse, Response},
+    },
+    model::order::{ORDER_UID_LIMIT, Order, OrderUid},
+    serde::Serialize,
+    std::sync::Arc,
+};
+
+#[expect(clippy::large_enum_variant)]
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+enum OrderResultEntry {
+    Order(Order),
+    Error(OrderError),
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct OrderError {
+    uid: OrderUid,
+    description: String,
+}
+
+pub async fn get_orders_by_uid_handler(
+    State(state): State<Arc<AppState>>,
+    axum::Json(orders): axum::Json<Vec<OrderUid>>,
+) -> Response {
+    if orders.len() > ORDER_UID_LIMIT {
+        return (
+            StatusCode::BAD_REQUEST,
+            format!("Request exceeds maximum number of order UIDs of {ORDER_UID_LIMIT}"),
+        )
+            .into_response();
+    }
+
+    get_orders_by_uid_response(state.orderbook.get_orders(&orders).await)
+}
+
+fn get_orders_by_uid_response(result: Result<Vec<(OrderUid, Result<Order>)>>) -> Response {
+    match result {
+        Ok(orders) => axum::Json(
+            orders
+                .into_iter()
+                .map(|(uid, order)| match order {
+                    Ok(order) => OrderResultEntry::Order(order),
+                    Err(err) => {
+                        tracing::warn!(?err, "Error converting into model order");
+                        OrderResultEntry::Error(OrderError {
+                            uid,
+                            description: "Internal server error encountered when retrieving the \
+                                          order"
+                                .to_string(),
+                        })
+                    }
+                })
+                .collect::<Vec<OrderResultEntry>>(),
+        )
+        .into_response(),
+        Err(err) => {
+            tracing::error!(?err, "get_orders_by_uid_response");
+            crate::api::internal_error_reply()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use {super::*, crate::api::response_body};
+
+    #[tokio::test]
+    async fn get_orders_by_uid_ok() {
+        let order = Order::default();
+        let uid = order.metadata.uid;
+        let result = vec![(uid, Ok(order.clone()))];
+        let response = get_orders_by_uid_response(Ok(result));
+        assert_eq!(response.status(), StatusCode::OK);
+
+        let body = response_body(response).await;
+        let entries: Vec<serde_json::Value> = serde_json::from_slice(&body).unwrap();
+        assert_eq!(entries.len(), 1);
+
+        let order_entry: Order =
+            serde_json::from_value(entries[0].get("order").expect("key order exists").clone())
+                .expect("value is a correct Order");
+        assert_eq!(order_entry, order);
+    }
+
+    #[tokio::test]
+    async fn get_orders_by_uid_conversion_error() {
+        let uid = OrderUid([1u8; 56]);
+        let result = vec![(uid, Err(anyhow::anyhow!("bad data")))];
+        let response = get_orders_by_uid_response(Ok(result));
+        assert_eq!(response.status(), StatusCode::OK);
+
+        let body = response_body(response).await;
+        let entries: Vec<serde_json::Value> = serde_json::from_slice(&body).unwrap();
+        assert_eq!(entries.len(), 1);
+
+        let error = entries[0].get("error").expect("error key exists");
+        let error_uid: OrderUid = error.get("uid").unwrap().as_str().unwrap().parse().unwrap();
+        assert_eq!(error_uid, uid);
+        assert_eq!(
+            error
+                .get("description")
+                .expect("key description exists")
+                .as_str()
+                .expect("description is a string"),
+            "Internal server error encountered when retrieving the order"
+        );
+    }
+
+    #[tokio::test]
+    async fn get_orders_by_uid_err() {
+        let response = get_orders_by_uid_response(Err(anyhow::anyhow!("error")));
+        assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    }
+}