fix(fortuna): Replace panic-causing constructs with safer alternatives

Co-Authored-By: Jayant Krishnamurthy <[email protected]>

Author: devin-ai-integration[bot]

apps/fortuna/src/api/metrics.rs

@@ -11,7 +11,10 @@ pub async fn metrics(State(state): State<crate::api::ApiState>) -> impl IntoResp
 
     // Should not fail if the metrics are valid and there is memory available
     // to write to the buffer.
-    encode(&mut buffer, &registry).unwrap();
+    if let Err(e) = encode(&mut buffer, &registry) {
+        tracing::error!("Failed to encode metrics: {}", e);
+        return axum::http::StatusCode::INTERNAL_SERVER_ERROR.into_response();
+    }
 
-    buffer
+    buffer.into_response()
 }

apps/fortuna/src/chain/ethereum.rs

@@ -82,7 +82,10 @@ impl<T: JsonRpcClient + 'static + Clone> SignablePythContractInner<T> {
             .await?
         {
             // Extract Log from TransactionReceipt.
-            let l: RawLog = r.logs[0].clone().into();
+            let l: RawLog = r.logs.first()
+                .ok_or_else(|| anyhow!("No logs in receipt"))?
+                .clone()
+                .into();
             if let PythRandomEvents::Requested1Filter(r) = PythRandomEvents::decode_log(&l)? {
                 Ok(r.request.sequence_number)
             } else {
@@ -112,7 +115,10 @@ impl<T: JsonRpcClient + 'static + Clone> SignablePythContractInner<T> {
             .await?
         {
             // Extract Log from TransactionReceipt.
-            let l: RawLog = r.logs[0].clone().into();
+            let l: RawLog = r.logs.first()
+                .ok_or_else(|| anyhow!("No logs in receipt"))?
+                .clone()
+                .into();
             if let PythRandomEvents::RequestedWithCallbackFilter(r) =
                 PythRandomEvents::decode_log(&l)?
             {
@@ -148,7 +154,10 @@ impl<T: JsonRpcClient + 'static + Clone> SignablePythContractInner<T> {
             .await?
         {
             if let PythRandomEvents::Revealed1Filter(r) =
-                PythRandomEvents::decode_log(&r.logs[0].clone().into())?
+                PythRandomEvents::decode_log(&r.logs.first()
+                    .ok_or_else(|| anyhow!("No logs in receipt"))?
+                    .clone()
+                    .into())?
             {
                 Ok(r.random_number)
             } else {

apps/fortuna/src/command/inspect.rs

@@ -37,7 +37,7 @@ async fn inspect_chain(
     let multicall_exists = rpc_provider
         .get_code(ethers::contract::MULTICALL_ADDRESS, None)
         .await
-        .expect("Failed to get code")
+        .map_err(|e| anyhow::anyhow!("Failed to get code: {}", e))?
         .len()
         > 0;
 
@@ -97,9 +97,9 @@ async fn process_request(
         let block = rpc_provider
             .get_block(request.block_number)
             .await?
-            .expect("Block not found");
+            .ok_or_else(|| anyhow::anyhow!("Block not found"))?;
         let datetime = chrono::DateTime::from_timestamp(block.timestamp.as_u64() as i64, 0)
-            .expect("Invalid timestamp");
+            .ok_or_else(|| anyhow::anyhow!("Invalid timestamp"))?;
         println!(
             "{} sequence_number:{} block_number:{} requester:{}",
             datetime, request.sequence_number, request.block_number, request.requester

apps/fortuna/src/command/run.rs

@@ -135,7 +135,10 @@ pub async fn run(opts: &RunOptions) -> Result<()> {
     // Listen for Ctrl+C so we can set the exit flag and wait for a graceful shutdown.
     spawn(async move {
         tracing::info!("Registered shutdown signal handler...");
-        tokio::signal::ctrl_c().await.unwrap();
+        tokio::signal::ctrl_c().await.map_err(|e| {
+            tracing::error!("Failed to register ctrl-c handler: {}", e);
+            Error::msg(format!("Failed to register ctrl-c handler: {}", e))
+        })?;
         tracing::info!("Shut down signal received, waiting for tasks...");
         // no need to handle error here, as it will only occur when all the
         // receiver has been dropped and that's what we want to do
@@ -220,7 +223,7 @@ async fn setup_chain_state(
     let last_prior_commitment = provider_commitments.last();
     if last_prior_commitment.is_some()
         && last_prior_commitment
-            .unwrap()
+            .ok_or_else(|| anyhow!("No prior commitment found"))?
             .original_commitment_sequence_number
             >= provider_info.original_commitment_sequence_number
     {

apps/fortuna/src/eth_utils/eth_gas_oracle.rs

@@ -108,14 +108,14 @@ pub fn eip1559_default_estimator(base_fee_per_gas: U256, rewards: Vec<Vec<U256>>
 fn estimate_priority_fee(rewards: Vec<Vec<U256>>) -> U256 {
     let mut rewards: Vec<U256> = rewards
         .iter()
-        .map(|r| r[0])
+        .map(|r| r.first().copied().unwrap_or_default())
         .filter(|r| *r > U256::zero())
         .collect();
     if rewards.is_empty() {
         return U256::zero();
     }
     if rewards.len() == 1 {
-        return rewards[0];
+        return rewards.first().copied().unwrap_or_default();
     }
     // Sort the rewards as we will eventually take the median.
     rewards.sort();
@@ -129,32 +129,33 @@ fn estimate_priority_fee(rewards: Vec<Vec<U256>>) -> U256 {
         .iter()
         .zip(rewards_copy.iter())
         .map(|(a, b)| {
-            let a = I256::try_from(*a).expect("priority fee overflow");
-            let b = I256::try_from(*b).expect("priority fee overflow");
+            let a = I256::try_from(*a).unwrap_or_default();
+            let b = I256::try_from(*b).unwrap_or_default();
             ((b - a) * 100) / a
         })
         .collect();
     percentage_change.pop();
 
     // Fetch the max of the percentage change, and that element's index.
-    let max_change = percentage_change.iter().max().unwrap();
+    let zero = I256::zero();
+    let max_change = percentage_change.iter().max().unwrap_or(&zero);
     let max_change_index = percentage_change
         .iter()
         .position(|&c| c == *max_change)
-        .unwrap();
+        .unwrap_or(0);
 
     // If we encountered a big change in fees at a certain position, then consider only
     // the values >= it.
     let values = if *max_change >= EIP1559_FEE_ESTIMATION_THRESHOLD_MAX_CHANGE.into()
         && (max_change_index >= (rewards.len() / 2))
     {
-        rewards[max_change_index..].to_vec()
+        rewards.get(max_change_index..).unwrap_or(&rewards).to_vec()
     } else {
         rewards
     };
 
     // Return the median.
-    values[values.len() / 2]
+    values.get(values.len() / 2).copied().unwrap_or_default()
 }
 
 fn base_fee_surged(base_fee_per_gas: U256) -> U256 {

apps/fortuna/src/eth_utils/traced_client.rs

@@ -120,7 +120,7 @@ impl TracedClient {
         let client = Client::builder()
             .timeout(Duration::from_secs(10))
             .build()
-            .expect("Failed to create HTTP client");
+            .map_err(|e| anyhow::anyhow!("Failed to create HTTP client: {}", e))?;
         Ok(Provider::new(TracedClient {
             inner: Http::new_with_client(url, client),
             chain_id,

apps/fortuna/src/keeper.rs

@@ -145,11 +145,11 @@ pub async fn run_keeper_threads(
             chain_eth_config.gas_limit,
             // NOTE: unwrap() here so we panic early if someone configures these values below -100.
             u64::try_from(100 + chain_eth_config.min_profit_pct)
-                .expect("min_profit_pct must be >= -100"),
+                .map_err(|_| anyhow::anyhow!("min_profit_pct must be >= -100"))?,
             u64::try_from(100 + chain_eth_config.target_profit_pct)
-                .expect("target_profit_pct must be >= -100"),
+                .map_err(|_| anyhow::anyhow!("target_profit_pct must be >= -100"))?,
             u64::try_from(100 + chain_eth_config.max_profit_pct)
-                .expect("max_profit_pct must be >= -100"),
+                .map_err(|_| anyhow::anyhow!("max_profit_pct must be >= -100"))?,
             chain_eth_config.fee,
             metrics.clone(),
         )

apps/fortuna/src/keeper/track.rs

@@ -56,10 +56,13 @@ pub async fn track_block_timestamp_lag(
         Ok(block) => match block {
             Some(block) => {
                 let block_timestamp = block.timestamp;
-                let server_timestamp = SystemTime::now()
-                    .duration_since(UNIX_EPOCH)
-                    .unwrap()
-                    .as_secs();
+                let server_timestamp = match SystemTime::now().duration_since(UNIX_EPOCH) {
+                    Ok(duration) => duration.as_secs(),
+                    Err(e) => {
+                        tracing::error!("Failed to get system time: {}", e);
+                        u64::MAX
+                    }
+                };
                 let lag: i64 = (server_timestamp as i64) - (block_timestamp.as_u64() as i64);
                 lag
             }

apps/fortuna/src/state.rs

@@ -94,7 +94,7 @@ impl PebbleHashChain {
         let sample_interval: usize = sample_interval.try_into()?;
         let hash_chain = spawn_blocking(move || Self::new(secret, chain_length, sample_interval))
             .await
-            .expect("Failed to make hash chain");
+            .map_err(|e| anyhow::anyhow!("Failed to make hash chain: {}", e))?;
 
         Ok(hash_chain)
     }
@@ -106,7 +106,8 @@ impl PebbleHashChain {
         // actually at the *front* of the list. Thus, it's easier to compute indexes from the end of the list.
         let index_from_end_of_subsampled_list = ((self.len() - 1) - i) / self.sample_interval;
         let mut i_index = self.len() - 1 - index_from_end_of_subsampled_list * self.sample_interval;
-        let mut val = self.hash[self.hash.len() - 1 - index_from_end_of_subsampled_list];
+        let mut val = *self.hash.get(self.hash.len().saturating_sub(1 + index_from_end_of_subsampled_list))
+            .ok_or_else(|| anyhow::anyhow!("Index out of bounds in hash chain"))?;
 
         while i_index > i {
             val = Keccak256::digest(val).into();
@@ -148,7 +149,11 @@ impl HashChainState {
             .ok_or(anyhow::anyhow!(
                 "Hash chain for the requested sequence number is not available."
             ))?;
-        self.hash_chains[chain_index].reveal_ith(sequence_number - self.offsets[chain_index])
+        let chain = self.hash_chains.get(chain_index)
+            .ok_or_else(|| anyhow::anyhow!("Chain index out of bounds"))?;
+        let offset = self.offsets.get(chain_index)
+            .ok_or_else(|| anyhow::anyhow!("Offset index out of bounds"))?;
+        chain.reveal_ith(sequence_number - offset)
     }
 }