fix: avoid allocation of into_iter

Author: krsnapaudel

backend/src/bridge/cache.rs

@@ -140,7 +140,7 @@ impl BridgeStatusCache {
         self.deposits
             .iter()
             .filter(|(_, entry)| filter(&entry.data.status))
-            .map(|(txid, entry)| (*txid, entry.data.clone()))
+            .map(|(txid, entry)| (*txid, entry.data))
             .collect()
     }
 
@@ -152,7 +152,7 @@ impl BridgeStatusCache {
         self.withdrawals
             .iter()
             .filter(|(_, entry)| filter(&entry.data.status))
-            .map(|(request_id, entry)| (*request_id, entry.data.clone()))
+            .map(|(request_id, entry)| (*request_id, entry.data))
             .collect()
     }
 
@@ -164,7 +164,7 @@ impl BridgeStatusCache {
         self.reimbursements
             .iter()
             .filter(|(_, entry)| filter(&entry.data.status))
-            .map(|(txid, entry)| (*txid, entry.data.clone()))
+            .map(|(txid, entry)| (*txid, entry.data))
             .collect()
     }
 

backend/src/bridge/status.rs

@@ -49,25 +49,6 @@ async fn get_tx_confirmations(esplora_url: &str, txid: Txid, chain_tip_height: u
         .unwrap_or(0)
 }
 
-/// Helper function to filter bridge status items based on confirmations
-async fn filter_by_confirmations<T>(
-    txid: Txid,
-    item: T,
-    config: &BridgeMonitoringConfig,
-    chain_tip_height: u64,
-) -> Option<(T, u64)>
-where
-    T: Clone,
-{
-    let confirmations = get_tx_confirmations(config.esplora_url(), txid, chain_tip_height).await;
-
-    if confirmations < config.max_tx_confirmations() {
-        Some((item, confirmations))
-    } else {
-        None
-    }
-}
-
 /// Determine which cached deposit entries should be purged
 async fn determine_deposits_to_purge(
     cache: &BridgeStatusCache,
@@ -148,7 +129,9 @@ async fn determine_reimbursements_to_purge(
             ReimbursementStatus::Complete => reimbursement_info
                 .payout_txid
                 .unwrap_or(reimbursement_info.claim_txid),
-            ReimbursementStatus::Challenged | ReimbursementStatus::InProgress => unreachable!(),
+            ReimbursementStatus::Challenged
+            | ReimbursementStatus::InProgress
+            | ReimbursementStatus::NotStarted => unreachable!(),
         };
 
         let current_confirmations =
@@ -208,13 +191,13 @@ pub async fn bridge_monitoring_task(context: Arc<BridgeMonitoringContext>) {
             let cache = context.status_cache.read().await;
             let deposits: Vec<Txid> = cache
                 .filter_deposits(|s| matches!(s, DepositStatus::InProgress))
-                .into_iter()
-                .map(|(txid, _)| txid)
+                .iter()
+                .map(|(txid, _)| *txid)
                 .collect();
             let withdrawals: Vec<Buf32> = cache
                 .filter_withdrawals(|s| matches!(s, WithdrawalStatus::InProgress))
-                .into_iter()
-                .map(|(request_id, _)| request_id)
+                .iter()
+                .map(|(request_id, _)| *request_id)
                 .collect();
             let reimbursements: Vec<Txid> = cache
                 .filter_reimbursements(|s| {
@@ -223,8 +206,8 @@ pub async fn bridge_monitoring_task(context: Arc<BridgeMonitoringContext>) {
                         ReimbursementStatus::InProgress | ReimbursementStatus::Challenged
                     )
                 })
-                .into_iter()
-                .map(|(txid, _)| txid)
+                .iter()
+                .map(|(txid, _)| *txid)
                 .collect();
             (deposits, withdrawals, reimbursements)
         };
@@ -233,8 +216,8 @@ pub async fn bridge_monitoring_task(context: Arc<BridgeMonitoringContext>) {
         let deposit_updates: Vec<(Txid, DepositInfo, u64)> =
             get_deposits(&context.config, chain_tip_height, &active_deposits)
                 .await
-                .into_iter()
-                .map(|(info, confirmations)| (info.deposit_request_txid, info, confirmations))
+                .iter()
+                .map(|(info, confirmations)| (info.deposit_request_txid, *info, *confirmations))
                 .collect();
 
         {
@@ -251,8 +234,8 @@ pub async fn bridge_monitoring_task(context: Arc<BridgeMonitoringContext>) {
         let withdrawal_updates: Vec<(Buf32, WithdrawalInfo, u64)> =
             get_withdrawals(&context.config, chain_tip_height, &active_withdrawals)
                 .await
-                .into_iter()
-                .map(|(info, confirmations)| (info.withdrawal_request_txid, info, confirmations))
+                .iter()
+                .map(|(info, confirmations)| (info.withdrawal_request_txid, *info, *confirmations))
                 .collect();
 
         {
@@ -269,8 +252,8 @@ pub async fn bridge_monitoring_task(context: Arc<BridgeMonitoringContext>) {
         let reimbursement_updates: Vec<(Txid, ReimbursementInfo, u64)> =
             get_reimbursements(&context.config, chain_tip_height, &active_reimbursements)
                 .await
-                .into_iter()
-                .map(|(info, confirmations)| (info.claim_txid, info, confirmations))
+                .iter()
+                .map(|(info, confirmations)| (info.claim_txid, *info, *confirmations))
                 .collect();
 
         {
@@ -388,15 +371,10 @@ async fn get_deposits(
                     RpcDepositStatus::InProgress => unreachable!(), // Already matched
                 };
 
-                if let Some(result) = filter_by_confirmations(
-                    txid,
-                    DepositInfo::from(&dep_info),
-                    config,
-                    chain_tip_height,
-                )
-                .await
-                {
-                    deposit_infos.push(result);
+                let confirmations =
+                    get_tx_confirmations(config.esplora_url(), txid, chain_tip_height).await;
+                if confirmations < config.max_tx_confirmations() {
+                    deposit_infos.push((DepositInfo::from(&dep_info), confirmations));
                 }
             }
         }
@@ -471,15 +449,11 @@ async fn get_withdrawals(
                 withdrawal_infos.push((WithdrawalInfo::from(&wd_info), 0));
             }
             RpcWithdrawalStatus::Complete { fulfillment_txid } => {
-                if let Some(result) = filter_by_confirmations(
-                    *fulfillment_txid,
-                    WithdrawalInfo::from(&wd_info),
-                    config,
-                    chain_tip_height,
-                )
-                .await
-                {
-                    withdrawal_infos.push(result);
+                let confirmations =
+                    get_tx_confirmations(config.esplora_url(), *fulfillment_txid, chain_tip_height)
+                        .await;
+                if confirmations < config.max_tx_confirmations() {
+                    withdrawal_infos.push((WithdrawalInfo::from(&wd_info), confirmations));
                 }
             }
         }
@@ -563,15 +537,10 @@ async fn get_reimbursements(
                     | RpcReimbursementStatus::InProgress { .. }
                     | RpcReimbursementStatus::Challenged { .. } => unreachable!(), // Already matched
                 };
-                if let Some(result) = filter_by_confirmations(
-                    txid,
-                    ReimbursementInfo::from(&claim_info),
-                    config,
-                    chain_tip_height,
-                )
-                .await
-                {
-                    reimbursement_infos.push(result);
+                let confirmations =
+                    get_tx_confirmations(config.esplora_url(), txid, chain_tip_height).await;
+                if confirmations < config.max_tx_confirmations() {
+                    reimbursement_infos.push((ReimbursementInfo::from(&claim_info), confirmations));
                 }
             }
         }

backend/src/bridge/types.rs

@@ -34,7 +34,7 @@ pub(crate) struct TxStatus {
     pub(crate) block_height: Option<u64>,
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Copy, Clone, Debug)]
 pub(crate) enum DepositStatus {
     #[serde(rename = "In progress")]
     InProgress,
@@ -43,7 +43,7 @@ pub(crate) enum DepositStatus {
 }
 
 /// Deposit information passed to status dashboard
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(Debug, Clone, Copy, Deserialize, Serialize)]
 pub(crate) struct DepositInfo {
     pub(crate) deposit_request_txid: Txid,
     pub(crate) deposit_txid: Option<Txid>,
@@ -73,15 +73,15 @@ impl From<&RpcDepositInfo> for DepositInfo {
 }
 
 /// Withdrawal status
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Copy, Clone, Debug)]
 pub(crate) enum WithdrawalStatus {
     #[serde(rename = "In progress")]
     InProgress,
     Complete,
 }
 
 /// Withdrawal information passed to status dashboard
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(Debug, Clone, Copy, Deserialize, Serialize)]
 pub(crate) struct WithdrawalInfo {
     pub(crate) withdrawal_request_txid: Buf32,
     pub(crate) fulfillment_txid: Option<Txid>,
@@ -106,20 +106,32 @@ impl From<&RpcWithdrawalInfo> for WithdrawalInfo {
 }
 
 /// Reimbursement status
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub enum ReimbursementStatus {
+#[derive(Serialize, Deserialize, Copy, Clone, Debug)]
+pub(crate) enum ReimbursementStatus {
+    #[serde(rename = "Not started")]
+    NotStarted,
     #[serde(rename = "In progress")]
     InProgress,
     Challenged,
     Cancelled,
     Complete,
 }
 
+/// Challenge step for reimbursements
+#[derive(Serialize, Deserialize, Copy, Clone, Debug)]
+pub(crate) enum ChallengeStep {
+    #[serde(rename = "N/A")]
+    NotApplicable,
+    Claim,
+    Challenge,
+    Assert,
+}
+
 /// Claim and reimbursement information passed to status dashboard
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(Debug, Clone, Copy, Deserialize, Serialize)]
 pub(crate) struct ReimbursementInfo {
     pub(crate) claim_txid: Txid,
-    pub(crate) challenge_step: String,
+    pub(crate) challenge_step: ChallengeStep,
     pub(crate) payout_txid: Option<Txid>,
     pub(crate) status: ReimbursementStatus,
 }
@@ -129,31 +141,31 @@ impl From<&RpcClaimInfo> for ReimbursementInfo {
         match &rpc_info.status {
             RpcReimbursementStatus::NotStarted => Self {
                 claim_txid: rpc_info.claim_txid,
-                challenge_step: "N/A".to_string(),
+                challenge_step: ChallengeStep::NotApplicable,
                 payout_txid: None,
-                status: ReimbursementStatus::InProgress,
+                status: ReimbursementStatus::NotStarted,
             },
-            RpcReimbursementStatus::InProgress { challenge_step, .. } => Self {
+            RpcReimbursementStatus::InProgress { .. } => Self {
                 claim_txid: rpc_info.claim_txid,
-                challenge_step: format!("{challenge_step:?}"),
+                challenge_step: ChallengeStep::Claim,
                 payout_txid: None,
                 status: ReimbursementStatus::InProgress,
             },
-            RpcReimbursementStatus::Challenged { challenge_step, .. } => Self {
+            RpcReimbursementStatus::Challenged { .. } => Self {
                 claim_txid: rpc_info.claim_txid,
-                challenge_step: format!("{challenge_step:?}"),
+                challenge_step: ChallengeStep::Challenge,
                 payout_txid: None,
                 status: ReimbursementStatus::Challenged,
             },
             RpcReimbursementStatus::Cancelled => Self {
                 claim_txid: rpc_info.claim_txid,
-                challenge_step: "N/A".to_string(),
+                challenge_step: ChallengeStep::NotApplicable,
                 payout_txid: None,
                 status: ReimbursementStatus::Cancelled,
             },
             RpcReimbursementStatus::Complete { payout_txid } => Self {
                 claim_txid: rpc_info.claim_txid,
-                challenge_step: "N/A".to_string(),
+                challenge_step: ChallengeStep::NotApplicable,
                 payout_txid: Some(*payout_txid),
                 status: ReimbursementStatus::Complete,
             },