Bid Status Visibility

auction-server/migrations/20240326063340_bids.up.sql

@@ -10,6 +10,5 @@ CREATE TABLE bid
     target_calldata BYTEA          NOT NULL,
     bid_amount      NUMERIC(78, 0) NOT NULL,
     status          bid_status     NOT NULL,
-    auction_id      UUID,     -- TODO: should be linked to the auction table in the future
-    removal_time    TIMESTAMP -- TODO: should be removed and read from the auction table in the future
+    auction_id      UUID
 );

auction-server/migrations/20240404172845_auction.down.sql

@@ -0,0 +1 @@
+DROP TABLE auction;

auction-server/migrations/20240404172845_auction.up.sql

@@ -0,0 +1,8 @@
+CREATE TABLE auction
+(
+    id              UUID PRIMARY KEY,
+    conclusion_time TIMESTAMP      NOT NULL,
+    permission_key  BYTEA          NOT NULL,
+    chain_id        TEXT           NOT NULL,
+    tx_hash         BYTEA          NOT NULL CHECK (LENGTH(tx_hash) = 32)
+);

auction-server/src/api.rs

@@ -20,6 +20,7 @@ use {
             SHOULD_EXIT,
         },
         state::{
+            AuctionParams,
             BidStatus,
             BidStatusWithId,
             OpportunityParams,
@@ -62,6 +63,7 @@ async fn root() -> String {
     format!("Express Relay Auction Server API {}", crate_version!())
 }
 
+pub(crate) mod auction;
 mod bid;
 pub(crate) mod opportunity;
 pub(crate) mod ws;
@@ -75,7 +77,9 @@ pub enum RestError {
     InvalidChainId,
     /// The simulation failed
     SimulationError { result: Bytes, reason: String },
-    /// The order was not found
+    /// The auction was not found
+    AuctionNotFound,
+    /// The opportunity was not found
     OpportunityNotFound,
     /// The bid was not found
     BidNotFound,
@@ -101,6 +105,10 @@ impl RestError {
                 StatusCode::BAD_REQUEST,
                 format!("Simulation failed: {} ({})", result, reason),
             ),
+            RestError::AuctionNotFound => (
+                StatusCode::NOT_FOUND,
+                "Auction with the specified id was not found".to_string(),
+            ),
             RestError::OpportunityNotFound => (
                 StatusCode::NOT_FOUND,
                 "Opportunity with the specified id was not found".to_string(),
@@ -144,10 +152,12 @@ pub async fn start_api(run_options: RunOptions, store: Arc<Store>) -> Result<()>
     opportunity::post_opportunity,
     opportunity::opportunity_bid,
     opportunity::get_opportunities,
+    auction::get_auctions,
     ),
     components(
     schemas(
     APIResponse,
+    AuctionParams,
     Bid,
     BidStatus,
     BidStatusWithId,
@@ -169,6 +179,7 @@ pub async fn start_api(run_options: RunOptions, store: Arc<Store>) -> Result<()>
     ErrorBodyResponse,
     OpportunityParamsWithMetadata,
     BidResult,
+    AuctionParams
     ),
     ),
     tags(
@@ -189,6 +200,7 @@ pub async fn start_api(run_options: RunOptions, store: Arc<Store>) -> Result<()>
             "/v1/opportunities/:opportunity_id/bids",
             post(opportunity::opportunity_bid),
         )
+        .route("/v1/auctions/:permission_key", get(auction::get_auctions))
         .route("/v1/ws", get(ws::ws_route_handler))
         .route("/live", get(live))
         .layer(CorsLayer::permissive())

auction-server/src/api/auction.rs

@@ -0,0 +1,117 @@
+use {
+    crate::{
+        api::{
+            opportunity::ChainIdQueryParams,
+            ErrorBodyResponse,
+            RestError,
+        },
+        state::{
+            AuctionId,
+            AuctionParams,
+            PermissionKey,
+            Store,
+        },
+    },
+    axum::{
+        extract::{
+            Path,
+            Query,
+            State,
+        },
+        Json,
+    },
+    ethers::types::H256,
+    serde::{
+        Deserialize,
+        Serialize,
+    },
+    std::sync::Arc,
+    utoipa::ToSchema,
+};
+
+#[derive(Serialize, Deserialize, ToSchema, Clone)]
+pub struct AuctionParamsWithId {
+    #[schema(value_type = String)]
+    pub id:     AuctionId,
+    pub params: AuctionParams,
+}
+
+/// Query for auctions with the permission key and (optionally) chain ID specified.
+#[utoipa::path(get, path = "/v1/auctions/{permission_key}",
+    params(
+        ("permission_key"=String, description = "Permission key to query for"),
+        ChainIdQueryParams
+    ),
+    responses(
+        (status = 200, description = "Array of auctions with the permission key", body = Vec<AuctionParams>),
+        (status = 400, response = ErrorBodyResponse),
+        (status = 404, description = "Permission key was not found", body = ErrorBodyResponse),
+    )
+)]
+pub async fn get_auctions(
+    State(store): State<Arc<Store>>,
+    Path(permission_key): Path<PermissionKey>,
+    query_params: Query<ChainIdQueryParams>,
+) -> Result<Json<Vec<AuctionParams>>, RestError> {
+    let auctions = match &query_params.chain_id {
+        Some(chain_id) => {
+            let auction_records = sqlx::query!(
+                "SELECT * FROM auction WHERE permission_key = $1 AND chain_id = $2",
+                permission_key.as_ref(),
+                chain_id
+            )
+            .fetch_all(&store.db)
+            .await
+            .map_err(|_| RestError::AuctionNotFound)?;
+
+            auction_records
+                .into_iter()
+                .map(|auction| AuctionParams {
+                    chain_id:       auction.chain_id,
+                    permission_key: auction.permission_key.into(),
+                    tx_hash:        H256::from_slice(auction.tx_hash.as_ref()),
+                })
+                .collect()
+        }
+        None => {
+            let auction_records = sqlx::query!(
+                "SELECT * FROM auction WHERE permission_key = $1",
+                permission_key.as_ref()
+            )
+            .fetch_all(&store.db)
+            .await
+            .map_err(|_| RestError::AuctionNotFound)?;
+
+            auction_records
+                .into_iter()
+                .map(|auction| AuctionParams {
+                    chain_id:       auction.chain_id,
+                    permission_key: auction.permission_key.into(),
+                    tx_hash:        H256::from_slice(auction.tx_hash.as_ref()),
+                })
+                .collect()
+        }
+    };
+
+    Ok(Json(auctions))
+}
+
+// Get auction with the specified ID.
+pub async fn get_auction_with_id(
+    store: Arc<Store>,
+    auction_id: AuctionId,
+) -> Result<AuctionParamsWithId, RestError> {
+    let auction = sqlx::query!("SELECT * FROM auction WHERE id = $1", auction_id)
+        .fetch_one(&store.db)
+        .await
+        .map_err(|_| RestError::BidNotFound)?;
+
+    Ok(AuctionParamsWithId {
+        id:     auction.id,
+        params: AuctionParams {
+            chain_id:       auction.chain_id,
+            permission_key: auction.permission_key.into(),
+            tx_hash:        H256::from_slice(auction.tx_hash.as_ref()),
+        },
+    })
+}

auction-server/src/api/bid.rs

@@ -1,6 +1,7 @@
 use {
     crate::{
         api::{
+            auction::get_auction_with_id,
             ErrorBodyResponse,
             RestError,
         },
@@ -80,8 +81,52 @@ pub async fn bid_status(
     State(store): State<Arc<Store>>,
     Path(bid_id): Path<BidId>,
 ) -> Result<Json<BidStatus>, RestError> {
-    match store.bids.read().await.get(&bid_id) {
-        Some(bid) => Ok(bid.status.clone().into()),
-        None => Err(RestError::BidNotFound),
+    let status_data = sqlx::query!(
+        // TODO: improve the call here to not cast to text
+        "SELECT status::text, auction_id FROM bid WHERE id = $1",
+        bid_id
+    )
+    .fetch_one(&store.db)
+    .await
+    .map_err(|_| RestError::BidNotFound)?;
+
+    let status_json: Json<BidStatus>;
+    match status_data.status {
+        Some(status) => {
+            if status == "pending" {
+                status_json = BidStatus::Pending.into();
+            } else if status == "lost" {
+                match status_data.auction_id {
+                    Some(auction_id) => {
+                        let auction_info = get_auction_with_id(store.clone(), auction_id).await?;
+                        status_json = BidStatus::Lost(auction_info.params.tx_hash).into();
+                    }
+                    None => {
+                        return Err(RestError::BadParameters(
+                            "Lost bid must have auction id".to_string(),
+                        ));
+                    }
+                }
+            } else if status == "submitted" {
+                match status_data.auction_id {
+                    Some(auction_id) => {
+                        let auction_info = get_auction_with_id(store.clone(), auction_id).await?;
+                        status_json = BidStatus::Submitted(auction_info.params.tx_hash).into();
+                    }
+                    None => {
+                        return Err(RestError::BadParameters(
+                            "Submitted bid must have auction id".to_string(),
+                        ));
+                    }
+                }
+            } else {
+                return Err(RestError::BadParameters("Invalid status".to_string()));
+            }
+        }
+        None => {
+            return Err(RestError::BidNotFound);
+        }
     }
+
+    Ok(status_json)
 }

auction-server/src/api/opportunity.rs

@@ -142,8 +142,8 @@ pub async fn post_opportunity(
 
 #[derive(Serialize, Deserialize, IntoParams)]
 pub struct ChainIdQueryParams {
-    #[param(example = "sepolia", value_type = Option < String >)]
-    chain_id: Option<ChainId>,
+    #[param(example = "op_sepolia", value_type = Option < String >)]
+    pub chain_id: Option<ChainId>,
 }
 
 /// Fetch all opportunities ready to be exectued.