Add more logs (#110)

Author: danimhr

auction-server/src/api.rs

@@ -109,6 +109,7 @@ pub(crate) mod opportunity;
 pub mod profile;
 pub(crate) mod ws;
 
+#[derive(Debug)]
 pub enum RestError {
     /// The request contained invalid parameters
     BadParameters(String),

auction-server/src/api/opportunity.rs

@@ -109,9 +109,17 @@ pub async fn post_opportunity(
 
     verify_opportunity(params.clone(), chain_store, store.relayer.address())
         .await
-        .map_err(|e| RestError::InvalidOpportunity(e.to_string()))?;
+        .map_err(|e| {
+            tracing::warn!(
+                "Failed to verify opportunity: {:?} - params: {:?}",
+                e,
+                versioned_params
+            );
+            RestError::InvalidOpportunity(e.to_string())
+        })?;
 
     if store.opportunity_exists(&opportunity).await {
+        tracing::warn!("Duplicate opportunity submission: {:?}", opportunity);
         return Err(RestError::BadParameters(
             "Duplicate opportunity submission".to_string(),
         ));
@@ -125,7 +133,11 @@ pub async fn post_opportunity(
             opportunity.clone(),
         )))
         .map_err(|e| {
-            tracing::error!("Failed to send update: {}", e);
+            tracing::error!(
+                "Failed to send update: {} - opportunity: {:?}",
+                e,
+                opportunity
+            );
             RestError::TemporarilyUnavailable
         })?;
 

auction-server/src/api/profile.rs

@@ -24,7 +24,7 @@ use {
     },
 };
 
-#[derive(Serialize, Deserialize, ToSchema, Clone, ToResponse)]
+#[derive(Serialize, Deserialize, ToSchema, Clone, ToResponse, Debug)]
 pub struct CreateProfile {
     /// The name of the profile to create
     #[schema(example = "John Doe")]

auction-server/src/auction.rs

@@ -290,13 +290,17 @@ async fn conclude_submitted_auction(store: Arc<Store>, auction: models::Auction)
                 {
                     if let Err(err) = store
                         .broadcast_bid_status_and_update(
-                            bid,
+                            bid.clone(),
                             get_bid_status(decoded_log, &receipt),
                             Some(&auction),
                         )
                         .await
                     {
-                        tracing::error!("Failed to broadcast bid status: {:?}", err);
+                        tracing::error!(
+                            "Failed to broadcast bid status: {:?} - bid: {:?}",
+                            err,
+                            bid
+                        );
                     }
                 }
             }))
@@ -317,9 +321,18 @@ async fn conclude_submitted_auctions(store: Arc<Store>, chain_id: String) {
     );
 
     for auction in auctions.iter() {
-        store
-            .task_tracker
-            .spawn(conclude_submitted_auction(store.clone(), auction.clone()));
+        store.task_tracker.spawn({
+            let (store, auction) = (store.clone(), auction.clone());
+            async move {
+                if let Err(err) = conclude_submitted_auction(store.clone(), auction.clone()).await {
+                    tracing::error!(
+                        "Failed to submit auction: {:?} - auction: {:?}",
+                        err,
+                        auction
+                    );
+                }
+            }
+        });
     }
 }
 
@@ -330,14 +343,22 @@ async fn broadcast_submitted_bids(
     auction: models::Auction,
 ) {
     join_all(bids.iter().enumerate().map(|(i, bid)| {
-        store.broadcast_bid_status_and_update(
-            bid.to_owned(),
-            BidStatus::Submitted {
-                result: tx_hash,
-                index:  i as u32,
-            },
-            Some(&auction),
-        )
+        let (store, auction, index) = (store.clone(), auction.clone(), i as u32);
+        async move {
+            if let Err(err) = store
+                .broadcast_bid_status_and_update(
+                    bid.to_owned(),
+                    BidStatus::Submitted {
+                        result: tx_hash,
+                        index,
+                    },
+                    Some(&auction),
+                )
+                .await
+            {
+                tracing::error!("Failed to broadcast bid status: {:?} - bid: {:?}", err, bid);
+            }
+        }
     }))
     .await;
 }
@@ -357,14 +378,22 @@ async fn broadcast_lost_bids(
             return None;
         }
 
-        Some(store.broadcast_bid_status_and_update(
-            bid.clone(),
-            BidStatus::Lost {
-                result: tx_hash,
-                index:  None,
-            },
-            auction,
-        ))
+        let store = store.clone();
+        Some(async move {
+            if let Err(err) = store
+                .broadcast_bid_status_and_update(
+                    bid.clone(),
+                    BidStatus::Lost {
+                        result: tx_hash,
+                        index:  None,
+                    },
+                    auction,
+                )
+                .await
+            {
+                tracing::error!("Failed to broadcast bid status: {:?} - bid: {:?}", err, bid);
+            }
+        })
     }))
     .await;
 }
@@ -506,7 +535,7 @@ pub fn get_express_relay_contract(
     SignableExpressRelayContract::new(address, client)
 }
 
-async fn submit_auctions(store: Arc<Store>, chain_id: String) -> Result<()> {
+async fn submit_auctions(store: Arc<Store>, chain_id: String) {
     let permission_keys = store.get_permission_keys_for_auction(&chain_id).await;
 
     tracing::info!(
@@ -516,13 +545,23 @@ async fn submit_auctions(store: Arc<Store>, chain_id: String) -> Result<()> {
     );
 
     for permission_key in permission_keys.iter() {
-        store.task_tracker.spawn(submit_auction(
-            store.clone(),
-            permission_key.clone(),
-            chain_id.clone(),
-        ));
+        store.task_tracker.spawn({
+            let (store, permission_key, chain_id) =
+                (store.clone(), permission_key.clone(), chain_id.clone());
+            async move {
+                if let Err(err) =
+                    submit_auction(store, permission_key.clone(), chain_id.clone()).await
+                {
+                    tracing::error!(
+                        "Failed to submit auction: {:?} - permission_key: {:?} - chain_id: {:?}",
+                        err,
+                        permission_key,
+                        chain_id
+                    );
+                }
+            }
+        });
     }
-    Ok(())
 }
 
 async fn get_ws_provider(store: Arc<Store>, chain_id: String) -> Result<Provider<Ws>> {
@@ -566,7 +605,7 @@ pub async fn run_submission_loop(store: Arc<Store>, chain_id: String) -> Result<
     Ok(())
 }
 
-#[derive(Serialize, Deserialize, ToSchema, Clone)]
+#[derive(Serialize, Deserialize, ToSchema, Clone, Debug)]
 pub struct Bid {
     /// The permission key to bid on.
     #[schema(example = "0xdeadbeef", value_type = String)]
@@ -669,13 +708,16 @@ pub async fn handle_bid(
     match call.clone().await {
         Ok(results) => {
             if !results[0].external_success {
+                // The call should be reverted because the "revert_on_failure" is set to true.
+                tracing::error!("Simulation failed and call is not reverted: {:?}", results,);
                 return Err(RestError::SimulationError {
                     result: results[0].external_result.clone(),
                     reason: results[0].multicall_revert_reason.clone(),
                 });
             }
         }
         Err(e) => {
+            tracing::warn!("Error while simulating bid: {:?}", e);
             return match e {
                 ContractError::Revert(reason) => {
                     if let Some(ExpressRelayErrors::ExternalCallFailed(failure_result)) =
@@ -698,10 +740,10 @@ pub async fn handle_bid(
         }
     }
 
-    let estimated_gas = call
-        .estimate_gas()
-        .await
-        .map_err(|_| RestError::TemporarilyUnavailable)?;
+    let estimated_gas = call.estimate_gas().await.map_err(|e| {
+        tracing::error!("Error while estimating gas: {:?}", e);
+        RestError::TemporarilyUnavailable
+    })?;
 
     verify_bid_exceeds_gas_cost(
         estimated_gas,

auction-server/src/models.rs

@@ -15,7 +15,7 @@ use {
     uuid::Uuid,
 };
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct TxHash(pub Option<H256>);
 
 impl From<Option<Vec<u8>>> for TxHash {
@@ -36,7 +36,7 @@ impl Deref for TxHash {
 }
 
 pub type AuctionId = Uuid;
-#[derive(Clone, FromRow)]
+#[derive(Clone, FromRow, Debug)]
 pub struct Auction {
     pub id:                  AuctionId,
     pub creation_time:       PrimitiveDateTime,
@@ -59,7 +59,7 @@ pub struct Opportunity {
     pub target_contract:   Vec<u8>,
     pub target_call_value: BigDecimal,
     pub target_calldata:   Vec<u8>,
-    pub removal_time:      PrimitiveDateTime,
+    pub removal_time:      Option<PrimitiveDateTime>,
     pub sell_tokens:       JsonValue,
     pub buy_tokens:        JsonValue,
 }

auction-server/src/opportunity_adapter.rs

@@ -184,8 +184,10 @@ pub async fn verify_opportunity(
             )
             .calldata()
             .ok_or(anyhow!(
-                "Failed to generate calldata for opportunity adapter"
-            ))?;
+        "Failed to generate calldata for opportunity adapter - params: {:?} - signature: {:?}",
+        params_with_signature.params,
+        signature
+    ))?;
 
     let call = get_simulation_call(
         relayer,
@@ -262,15 +264,20 @@ pub async fn verify_opportunity(
             if !result.multicall_statuses[0].external_success {
                 tracing::info!(
                     "Opportunity simulation failed: {:?}",
-                    result.multicall_statuses[0]
+                    result.multicall_statuses
                 );
                 return Err(anyhow!(
                     "Express Relay Simulation failed: {:?}",
-                    result.multicall_statuses[0].external_result
+                    result.multicall_statuses
                 ));
             }
         }
-        Err(e) => return Err(anyhow!(format!("Error decoding multicall result: {:?}", e))),
+        Err(e) => {
+            return Err(anyhow!(format!(
+                "Error decoding multicall result: {:?} - result: {:?}",
+                e, result
+            )))
+        }
     }
     Ok(VerificationResult::Success)
 }
@@ -619,34 +626,43 @@ pub async fn handle_opportunity_bid(
     let adapter_calldata =
         make_adapter_calldata(params.clone(), opportunity_bid.clone(), chain_store)
             .await
-            .map_err(|e| RestError::BadParameters(e.to_string()))?;
-    match handle_bid(
-        store.clone(),
-        Bid {
-            permission_key:  params.permission_key.clone(),
-            chain_id:        params.chain_id.clone(),
-            target_contract: chain_store.config.adapter_factory_contract,
-            target_calldata: adapter_calldata,
-            amount:          opportunity_bid.amount,
-        },
-        initiation_time,
-        auth,
-    )
-    .await
-    {
+            .map_err(|e| {
+                tracing::error!(
+                    "Error making adapter calldata: {:?} - opportunity: {:?}",
+                    e,
+                    opportunity
+                );
+                RestError::BadParameters(e.to_string())
+            })?;
+    let bid = Bid {
+        permission_key:  params.permission_key.clone(),
+        chain_id:        params.chain_id.clone(),
+        target_contract: chain_store.config.adapter_factory_contract,
+        target_calldata: adapter_calldata,
+        amount:          opportunity_bid.amount,
+    };
+    match handle_bid(store.clone(), bid.clone(), initiation_time, auth).await {
         Ok(id) => Ok(id),
-        Err(e) => match e {
-            RestError::SimulationError { result, reason } => {
-                let parsed = parse_revert_error(&result);
-                match parsed {
-                    Some(decoded) => Err(RestError::BadParameters(decoded)),
-                    None => {
-                        tracing::info!("Could not parse revert reason: {}", reason);
-                        Err(RestError::SimulationError { result, reason })
+        Err(e) => {
+            tracing::warn!(
+                "Error handling bid: {:?} - opportunity: {:?} - bid: {:?}",
+                e,
+                opportunity,
+                bid
+            );
+            match e {
+                RestError::SimulationError { result, reason } => {
+                    let parsed = parse_revert_error(&result);
+                    match parsed {
+                        Some(decoded) => Err(RestError::BadParameters(decoded)),
+                        None => {
+                            tracing::info!("Could not parse revert reason: {}", reason);
+                            Err(RestError::SimulationError { result, reason })
+                        }
                     }
                 }
+                _ => Err(e),
             }
-            _ => Err(e),
-        },
+        }
     }
 }