BM-272: Fix expired status (github#100)

A proof request is expired when the current block number is greater than
the sum `startBidding` + `timeout` and it's not fulfilled. A proof
request expiration is stored into the contract state only during a
`lockinRequest`. As such, querying the status of an expired proof
request yields an `expired` response only if the proof request has been
locked in, and `unknown` otherwise. To minimise this limitation, the
`get_status` method accept an optional `expires_at` parameter the caller
should provide. The same parameter is made mandatory for the
`wait_for_proof_fulfillment` method.

---------

Co-authored-by: Victor Graf <[email protected]>

Author: capossele

crates/boundless-market/src/bin/cli.rs

@@ -72,9 +72,6 @@ enum Command {
     GetProof {
         /// The proof request identifier
         request_id: U256,
-        /// Wait until the request is fulfilled
-        #[clap(short, long, default_value = "false")]
-        wait: bool,
     },
     /// Verify the proof of the given request against
     /// the SetVerifier contract.
@@ -88,6 +85,8 @@ enum Command {
     Status {
         /// The proof request identifier
         request_id: U256,
+        /// The block number at which the request expires
+        expires_at: Option<u64>,
     },
 }
 
@@ -204,25 +203,16 @@ async fn main() -> Result<()> {
             market.slash(request_id).await?;
             tracing::info!("Request slashed: 0x{request_id:x}");
         }
-        Command::GetProof { request_id, wait } => {
-            let (journal, seal) = if wait {
-                market
-                    .wait_for_request_fulfillment(request_id, Duration::from_secs(5), None)
-                    .await?
-            } else {
-                market.get_request_fulfillment(request_id).await?
-            };
+        Command::GetProof { request_id } => {
+            let (journal, seal) = market.get_request_fulfillment(request_id).await?;
             tracing::info!(
                 "Journal: {} - Seal: {}",
                 serde_json::to_string_pretty(&journal)?,
                 serde_json::to_string_pretty(&seal)?
             );
         }
         Command::VerifyProof { request_id, image_id } => {
-            let (journal, seal) = market
-                .wait_for_request_fulfillment(request_id, Duration::from_secs(5), None)
-                .await?;
-
+            let (journal, seal) = market.get_request_fulfillment(request_id).await?;
             let journal_digest = <[u8; 32]>::from(Journal::new(journal.to_vec()).digest()).into();
             set_verifier
                 .verify(seal, image_id, journal_digest)
@@ -231,8 +221,8 @@ async fn main() -> Result<()> {
                 .map_err(|_| anyhow::anyhow!("Verification failed"))?;
             tracing::info!("Proof for request id 0x{request_id:x} verified successfully.");
         }
-        Command::Status { request_id } => {
-            let status = market.get_status(request_id).await?;
+        Command::Status { request_id, expires_at } => {
+            let status = market.get_status(request_id, expires_at).await?;
             tracing::info!("Status: {:?}", status);
         }
     };
@@ -336,8 +326,9 @@ where
     );
 
     if args.wait {
-        let (journal, seal) =
-            market.wait_for_request_fulfillment(request_id, Duration::from_secs(5), None).await?;
+        let (journal, seal) = market
+            .wait_for_request_fulfillment(request_id, Duration::from_secs(5), request.expires_at())
+            .await?;
         tracing::info!(
             "Journal: {} - Seal: {}",
             serde_json::to_string_pretty(&journal)?,
@@ -396,8 +387,9 @@ where
     );
 
     if wait {
-        let (journal, seal) =
-            market.wait_for_request_fulfillment(request_id, Duration::from_secs(5), None).await?;
+        let (journal, seal) = market
+            .wait_for_request_fulfillment(request_id, Duration::from_secs(5), request.expires_at())
+            .await?;
         tracing::info!(
             "Journal: {} - Seal: {}",
             serde_json::to_string_pretty(&journal)?,

crates/boundless-market/src/contracts/mod.rs

@@ -130,6 +130,11 @@ impl ProvingRequest {
         Self { offer, ..self }
     }
 
+    /// Returns the block number at which the request expires.
+    pub fn expires_at(&self) -> u64 {
+        self.offer.biddingStart + self.offer.timeout as u64
+    }
+
     /// Check that the request is valid and internally consistent.
     ///
     /// If any field are empty, or if two fields conflict (e.g. the max price is less than the min

crates/boundless-market/src/contracts/proof_market.rs

@@ -2,7 +2,7 @@
 //
 // All rights reserved.
 
-use std::time::{Duration, Instant};
+use std::time::Duration;
 
 use alloy::{
     network::Ethereum,
@@ -441,22 +441,33 @@ where
     }
 
     /// Returns the [ProofStatus] of a proving request.
-    pub async fn get_status(&self, request_id: U256) -> Result<ProofStatus, MarketError> {
+    ///
+    /// The `expires_at` parameter is the block number at which the request expires.
+    pub async fn get_status(
+        &self,
+        request_id: U256,
+        expires_at: Option<u64>,
+    ) -> Result<ProofStatus, MarketError> {
         let block_number = self.get_latest_block().await?;
 
         if self.is_fulfilled(request_id).await.context("Failed to check fulfillment status")? {
             return Ok(ProofStatus::Fulfilled);
         }
 
+        if let Some(expires_at) = expires_at {
+            if block_number > expires_at {
+                return Ok(ProofStatus::Expired);
+            }
+        }
+
         if self.is_locked_in(request_id).await.context("Failed to check locked status")? {
+            let deadline = self.instance.requestDeadline(U192::from(request_id)).call().await?._0;
+            if block_number > deadline && deadline > 0 {
+                return Ok(ProofStatus::Expired);
+            };
             return Ok(ProofStatus::Locked);
         }
 
-        let deadline = self.instance.requestDeadline(U192::from(request_id)).call().await?._0;
-        if block_number > deadline && deadline > 0 {
-            return Ok(ProofStatus::Expired);
-        };
-
         Ok(ProofStatus::Unknown)
     }
 
@@ -526,7 +537,7 @@ where
         &self,
         request_id: U256,
     ) -> Result<(Bytes, Bytes), MarketError> {
-        match self.get_status(request_id).await? {
+        match self.get_status(request_id, None).await? {
             ProofStatus::Expired => Err(MarketError::RequestHasExpired(request_id)),
             ProofStatus::Fulfilled => self.query_fulfilled_event(request_id, None, None).await,
             _ => Err(MarketError::RequestNotFulfilled(request_id)),
@@ -542,16 +553,10 @@ where
         &self,
         request_id: U256,
         retry_interval: Duration,
-        timeout: Option<Duration>,
+        expires_at: u64,
     ) -> Result<(Bytes, Bytes), MarketError> {
-        let start_time = Instant::now();
         loop {
-            if let Some(timeout_duration) = timeout {
-                if start_time.elapsed() >= timeout_duration {
-                    return Err(MarketError::TimeoutReached(request_id));
-                }
-            }
-            let status = self.get_status(request_id).await?;
+            let status = self.get_status(request_id, Some(expires_at)).await?;
             match status {
                 ProofStatus::Expired => return Err(MarketError::RequestHasExpired(request_id)),
                 ProofStatus::Fulfilled => {
@@ -624,7 +629,7 @@ where
             .context(format!("Failed to get EOA nonce for {:?}", self.caller))?;
         let id: u32 = nonce.try_into().context("Failed to convert nonce to u32")?;
         let request_id = request_id(&self.caller, id);
-        match self.get_status(U256::from(request_id)).await? {
+        match self.get_status(U256::from(request_id), None).await? {
             ProofStatus::Unknown => return Ok(id),
             _ => Err(MarketError::Error(anyhow!("index already in use"))),
         }
@@ -882,6 +887,7 @@ mod tests {
         };
 
         let request = new_request(1, &ctx).await;
+        let expires_at = request.expires_at();
 
         let request_id =
             ctx.customer_market.submit_request(&request, &ctx.customer_signer).await.unwrap();
@@ -900,7 +906,10 @@ mod tests {
         // Lockin the request
         ctx.prover_market.lockin_request(&request, &customer_sig, None).await.unwrap();
         assert!(ctx.customer_market.is_locked_in(request_id).await.unwrap());
-        assert!(ctx.customer_market.get_status(request_id).await.unwrap() == ProofStatus::Locked);
+        assert!(
+            ctx.customer_market.get_status(request_id, Some(expires_at)).await.unwrap()
+                == ProofStatus::Locked
+        );
 
         // mock the fulfillment
         let (root, set_verifier_seal, fulfillment, market_seal) =
@@ -937,6 +946,7 @@ mod tests {
         };
 
         let request = new_request(1, &ctx).await;
+        let expires_at = request.expires_at();
 
         let request_id =
             ctx.customer_market.submit_request(&request, &ctx.customer_signer).await.unwrap();
@@ -955,7 +965,10 @@ mod tests {
         // Lockin the request
         ctx.prover_market.lockin_request(&request, &customer_sig, None).await.unwrap();
         assert!(ctx.customer_market.is_locked_in(request_id).await.unwrap());
-        assert!(ctx.customer_market.get_status(request_id).await.unwrap() == ProofStatus::Locked);
+        assert!(
+            ctx.customer_market.get_status(request_id, Some(expires_at)).await.unwrap()
+                == ProofStatus::Locked
+        );
 
         // mock the fulfillment
         let (root, set_verifier_seal, fulfillment, market_seal) =

crates/boundless-market/src/sdk/client.rs

@@ -148,11 +148,11 @@ where
         &self,
         request_id: U256,
         check_interval: std::time::Duration,
-        timeout: Option<std::time::Duration>,
+        expires_at: u64,
     ) -> Result<(Bytes, Bytes), ClientError> {
         Ok(self
             .proof_market
-            .wait_for_request_fulfillment(request_id, check_interval, timeout)
+            .wait_for_request_fulfillment(request_id, check_interval, expires_at)
             .await?)
     }
 }

crates/broker/src/market_monitor.rs

@@ -122,13 +122,14 @@ where
                 continue;
             }
 
-            let req_status = match market.get_status(request_id).await {
-                Ok(val) => val,
-                Err(err) => {
-                    tracing::warn!("Failed to get request status: {err:?}");
-                    continue;
-                }
-            };
+            let req_status =
+                match market.get_status(request_id, Some(event.request.expires_at())).await {
+                    Ok(val) => val,
+                    Err(err) => {
+                        tracing::warn!("Failed to get request status: {err:?}");
+                        continue;
+                    }
+                };
 
             if !matches!(req_status, ProofStatus::Unknown) {
                 tracing::debug!(

crates/broker/src/order_monitor.rs

@@ -81,8 +81,11 @@ where
             return Err(LockOrderErr::InvalidStatus(order.status));
         }
 
-        let order_status =
-            self.market.get_status(order_id).await.context("Failed to get order status")?;
+        let order_status = self
+            .market
+            .get_status(order_id, Some(order.request.expires_at()))
+            .await
+            .context("Failed to get order status")?;
         if order_status != ProofStatus::Unknown {
             tracing::warn!("Order {order_id:x} not open: {order_status:?}, skipping");
             // TODO: fetch some chain data to find out who / and for how much the order

crates/broker/src/tests/e2e.rs

@@ -104,7 +104,7 @@ async fn simple_e2e() {
         .wait_for_request_fulfillment(
             U256::from(request.id),
             Duration::from_secs(1),
-            Some(Duration::from_secs(60)),
+            request.expires_at(),
         )
         .await
         .unwrap();

examples/counter/apps/src/main.rs

@@ -173,7 +173,7 @@ async fn run(
         .wait_for_request_fulfillment(
             request_id,
             Duration::from_secs(5), // check every 5 seconds
-            None,                   // no timeout
+            request.expires_at(),
         )
         .await?;
     tracing::info!("Request {} fulfilled", request_id);