minor refactor

Fraccaman · Fraccaman · commit 3c988c618c41 · 2025-10-16T15:05:22.000+02:00
diff --git a/webserver/src/dto/transaction.rs b/webserver/src/dto/transaction.rs
@@ -1,4 +1,3 @@
-use serde::de::value::StrDeserializer;
 use serde::{Deserialize, Serialize};
 use subtle_encoding::hex;
 use validator::Validate;
@@ -42,69 +41,8 @@ pub struct TransactionMostRecentQueryParams {
     pub offset: Option<u64>,
     #[validate(range(min = 10, max = 30))]
     pub size: Option<u64>,
-    #[serde(default, deserialize_with = "deserialize_kinds_vec")]
+    #[serde(default)]
     pub kind: Vec<TransactionKind>,
-    #[serde(default, deserialize_with = "deserialize_tokens_vec")]
+    #[serde(default)]
     pub token: Vec<String>,
 }
-
-// Parse the comma separated list of tx kinds from the query string into a vec
-// of validated tx kinds
-#[derive(Deserialize)]
-#[serde(untagged)]
-enum KindList {
-    List(Vec<TransactionKind>),
-    Csv(String),
-}
-
-fn deserialize_kinds_vec<'de, D>(
-    deserializer: D,
-) -> Result<Vec<TransactionKind>, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    let opt = Option::<KindList>::deserialize(deserializer)?;
-    let vec = match opt {
-        None => Vec::new(),
-        Some(KindList::List(v)) => v,
-        Some(KindList::Csv(s)) => s
-            .split(',')
-            .filter(|p| !p.is_empty())
-            .map(|p| p.trim())
-            .map(|p| {
-                TransactionKind::deserialize(StrDeserializer::<D::Error>::new(
-                    p,
-                ))
-            })
-            .collect::<Result<Vec<_>, _>>()?,
-    };
-    Ok(vec)
-}
-
-// Parse the comma separated list of token addresses from the query string into
-// a vec of strings
-#[derive(Deserialize)]
-#[serde(untagged)]
-enum TokenList {
-    List(Vec<String>),
-    Csv(String),
-}
-
-fn deserialize_tokens_vec<'de, D>(
-    deserializer: D,
-) -> Result<Vec<String>, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    let opt = Option::<TokenList>::deserialize(deserializer)?;
-    let vec = match opt {
-        None => Vec::new(),
-        Some(TokenList::List(v)) => v,
-        Some(TokenList::Csv(s)) => s
-            .split(',')
-            .filter(|p| !p.is_empty())
-            .map(|p| p.trim().to_string())
-            .collect(),
-    };
-    Ok(vec)
-}
diff --git a/webserver/src/entity/transaction.rs b/webserver/src/entity/transaction.rs
@@ -77,6 +77,43 @@ impl From<TransactionKindDb> for TransactionKind {
     }
 }
 
+impl From<TransactionKind> for TransactionKindDb {
+    fn from(value: TransactionKind) -> Self {
+        match value {
+            TransactionKind::TransparentTransfer => Self::TransparentTransfer,
+            TransactionKind::ShieldedTransfer => Self::ShieldedTransfer,
+            TransactionKind::ShieldingTransfer => Self::ShieldingTransfer,
+            TransactionKind::UnshieldingTransfer => Self::UnshieldingTransfer,
+            TransactionKind::MixedTransfer => Self::MixedTransfer,
+            TransactionKind::Bond => Self::Bond,
+            TransactionKind::Redelegation => Self::Redelegation,
+            TransactionKind::Unbond => Self::Unbond,
+            TransactionKind::Withdraw => Self::Withdraw,
+            TransactionKind::ClaimRewards => Self::ClaimRewards,
+            TransactionKind::VoteProposal => Self::VoteProposal,
+            TransactionKind::InitProposal => Self::InitProposal,
+            TransactionKind::ChangeMetadata => Self::ChangeMetadata,
+            TransactionKind::ChangeCommission => Self::ChangeCommission,
+            TransactionKind::RevealPk => Self::RevealPk,
+            TransactionKind::Unknown => Self::Unknown,
+            TransactionKind::IbcMsgTransfer => Self::IbcMsgTransfer,
+            TransactionKind::IbcTransparentTransfer => {
+                Self::IbcTransparentTransfer
+            }
+            TransactionKind::IbcShieldingTransfer => Self::IbcShieldingTransfer,
+            TransactionKind::IbcUnshieldingTransfer => {
+                Self::IbcUnshieldingTransfer
+            }
+            TransactionKind::BecomeValidator => Self::BecomeValidator,
+            TransactionKind::ReactivateValidator => Self::ReactivateValidator,
+            TransactionKind::DeactivateValidator => Self::DeactivateValidator,
+            TransactionKind::UnjailValidator => Self::UnjailValidator,
+            TransactionKind::ChangeConsensusKey => Self::ChangeConsensusKey,
+            TransactionKind::InitAccount => Self::InitAccount,
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct WrapperTransaction {
     pub id: Id,
diff --git a/webserver/src/handler/transaction.rs b/webserver/src/handler/transaction.rs
@@ -5,6 +5,7 @@ use axum_extra::extract::Query;
 use axum_macros::debug_handler;
 use serde_json;
 
+use crate::constant::ITEM_PER_PAGE;
 use crate::dto::transaction::{
     TransactionHistoryQueryParams, TransactionIdParam,
     TransactionMostRecentQueryParams,
@@ -106,83 +107,55 @@ pub async fn get_most_recent_transactions(
     State(state): State<CommonState>,
 ) -> Result<Json<Vec<WrapperTransactionResponse>>, ApiError> {
     let offset = query.offset.unwrap_or(0);
-    let size = query.size.unwrap_or(10);
+    let size = query.size.unwrap_or(ITEM_PER_PAGE);
     let kind = query.kind;
     let token = query.token;
 
     let filters_present = !kind.is_empty() || !token.is_empty();
 
-    if !filters_present {
-        // If no filters are needed, we can just page over the wrapper tx table
-        // directly
-        let transactions = state
+    let wrappers = if !filters_present {
+        state
             .transaction_service
             .get_most_recent_transactions(offset, size)
-            .await?;
-
-        let inner_txs = transactions
-            .iter()
-            .map(|tx| {
-                state
-                    .transaction_service
-                    .get_inner_tx_by_wrapper_id(tx.id.to_string())
-            })
-            .collect::<Vec<_>>();
-
-        let inner_txs = futures::future::join_all(inner_txs).await;
-
-        let response = transactions
-            .into_iter()
-            .zip(inner_txs.into_iter())
-            .map(|(tx, inner_tx_result)| {
-                let inner_txs = inner_tx_result.unwrap_or_default();
-                WrapperTransactionResponse::new(tx, inner_txs)
-            })
-            .collect();
-
-        return Ok(Json(response));
-    }
-
-    // Filtering by tx kind and/or transfer token:
-    // First, search for and return 'size' number of wrappers that have at least
-    // one inner tx matching the filters
-    let candidates = state
-        .transaction_service
-        .get_filtered_most_recent_wrappers(
-            offset,
-            size,
-            kind.clone(),
-            token.clone(),
-        )
-        .await?;
+            .await?
+    } else {
+        state
+            .transaction_service
+            .get_filtered_most_recent_wrappers(
+                offset,
+                size,
+                kind.clone(),
+                token.clone(),
+            )
+            .await?
+    };
 
-    // Filter the corresponding inner txs to include only the matching inners in
-    // the response
-    let inner_futs = candidates.iter().map(|tx| {
+    let inner_futs = wrappers.iter().map(|tx| {
         state
             .transaction_service
             .get_inner_tx_by_wrapper_id(tx.id.to_string())
     });
-
     let inner_results = futures::future::join_all(inner_futs).await;
 
-    let response = candidates
+    let response = wrappers
         .into_iter()
         .zip(inner_results.into_iter())
         .filter_map(|(tx, inner_res)| {
             let mut inners = inner_res.unwrap_or_default();
 
-            if !kind.is_empty() {
-                inners.retain(|inner_tx| kind.contains(&inner_tx.kind));
-            }
-            if !token.is_empty() {
-                inners.retain(|inner_tx| {
-                    filter_inner_tx_by_tokens(inner_tx, &token)
-                });
-            }
+            if filters_present {
+                if !kind.is_empty() {
+                    inners.retain(|inner_tx| kind.contains(&inner_tx.kind));
+                }
+                if !token.is_empty() {
+                    inners.retain(|inner_tx| {
+                        filter_inner_tx_by_tokens(inner_tx, &token)
+                    });
+                }
 
-            if inners.is_empty() {
-                return None;
+                if inners.is_empty() {
+                    return None;
+                }
             }
 
             Some(WrapperTransactionResponse::new(tx, inners))
diff --git a/webserver/src/repository/transaction.rs b/webserver/src/repository/transaction.rs
@@ -15,7 +15,6 @@ use orm::transactions::{
 
 use super::utils::{Paginate, PaginatedResponseDb};
 use crate::appstate::AppState;
-use crate::entity::transaction::TransactionKind;
 
 #[derive(Clone)]
 pub struct TransactionRepository {
@@ -60,7 +59,7 @@ pub trait TransactionRepositoryTrait {
         &self,
         offset: i64,
         size: i32,
-        kinds: Vec<TransactionKind>,
+        kinds: Vec<TransactionKindDb>,
         tokens: Vec<String>,
     ) -> Result<Vec<WrapperTransactionDb>, String>;
 }
@@ -190,7 +189,7 @@ impl TransactionRepositoryTrait for TransactionRepository {
         &self,
         offset: i64,
         size: i32,
-        kinds: Vec<TransactionKind>,
+        kinds: Vec<TransactionKindDb>,
         tokens: Vec<String>,
     ) -> Result<Vec<WrapperTransactionDb>, String> {
         let conn = self.app_state.get_db_connection().await;
@@ -201,92 +200,12 @@ impl TransactionRepositoryTrait for TransactionRepository {
 
             // 1) Kind filter using typed enum mapping (apply as its own EXISTS)
             if !kinds.is_empty() {
-                fn map_kind(k: &TransactionKind) -> TransactionKindDb {
-                    match k {
-                        TransactionKind::TransparentTransfer => {
-                            TransactionKindDb::TransparentTransfer
-                        }
-                        TransactionKind::ShieldedTransfer => {
-                            TransactionKindDb::ShieldedTransfer
-                        }
-                        TransactionKind::ShieldingTransfer => {
-                            TransactionKindDb::ShieldingTransfer
-                        }
-                        TransactionKind::UnshieldingTransfer => {
-                            TransactionKindDb::UnshieldingTransfer
-                        }
-                        TransactionKind::MixedTransfer => {
-                            TransactionKindDb::MixedTransfer
-                        }
-                        TransactionKind::Bond => TransactionKindDb::Bond,
-                        TransactionKind::Redelegation => {
-                            TransactionKindDb::Redelegation
-                        }
-                        TransactionKind::Unbond => TransactionKindDb::Unbond,
-                        TransactionKind::Withdraw => {
-                            TransactionKindDb::Withdraw
-                        }
-                        TransactionKind::ClaimRewards => {
-                            TransactionKindDb::ClaimRewards
-                        }
-                        TransactionKind::VoteProposal => {
-                            TransactionKindDb::VoteProposal
-                        }
-                        TransactionKind::InitProposal => {
-                            TransactionKindDb::InitProposal
-                        }
-                        TransactionKind::ChangeMetadata => {
-                            TransactionKindDb::ChangeMetadata
-                        }
-                        TransactionKind::ChangeCommission => {
-                            TransactionKindDb::ChangeCommission
-                        }
-                        TransactionKind::RevealPk => {
-                            TransactionKindDb::RevealPk
-                        }
-                        TransactionKind::IbcMsgTransfer => {
-                            TransactionKindDb::IbcMsgTransfer
-                        }
-                        TransactionKind::IbcTransparentTransfer => {
-                            TransactionKindDb::IbcTransparentTransfer
-                        }
-                        TransactionKind::IbcShieldingTransfer => {
-                            TransactionKindDb::IbcShieldingTransfer
-                        }
-                        TransactionKind::IbcUnshieldingTransfer => {
-                            TransactionKindDb::IbcUnshieldingTransfer
-                        }
-                        TransactionKind::BecomeValidator => {
-                            TransactionKindDb::BecomeValidator
-                        }
-                        TransactionKind::DeactivateValidator => {
-                            TransactionKindDb::DeactivateValidator
-                        }
-                        TransactionKind::ReactivateValidator => {
-                            TransactionKindDb::ReactivateValidator
-                        }
-                        TransactionKind::UnjailValidator => {
-                            TransactionKindDb::UnjailValidator
-                        }
-                        TransactionKind::ChangeConsensusKey => {
-                            TransactionKindDb::ChangeConsensusKey
-                        }
-                        TransactionKind::InitAccount => {
-                            TransactionKindDb::InitAccount
-                        }
-                        TransactionKind::Unknown => TransactionKindDb::Unknown,
-                    }
-                }
-
-                let kinds_db: Vec<TransactionKindDb> =
-                    kinds.iter().map(map_kind).collect();
-
                 let inner_by_kind = inner_transactions::table
                     .filter(
                         inner_transactions::dsl::wrapper_id
                             .eq(wrapper_transactions::dsl::id),
                     )
-                    .filter(inner_transactions::dsl::kind.eq_any(kinds_db));
+                    .filter(inner_transactions::dsl::kind.eq_any(kinds));
 
                 outer = outer.filter(exists(inner_by_kind));
             }
@@ -295,7 +214,7 @@ impl TransactionRepositoryTrait for TransactionRepository {
             //    EXISTS)
             if !tokens.is_empty() {
                 // regular transfer kinds (non-IBC)
-                let regular_kinds: Vec<TransactionKindDb> = vec![
+                let regular_kinds = [
                     TransactionKindDb::TransparentTransfer,
                     TransactionKindDb::ShieldedTransfer,
                     TransactionKindDb::ShieldingTransfer,
@@ -304,7 +223,7 @@ impl TransactionRepositoryTrait for TransactionRepository {
                 ];
 
                 // IBC transfer kinds
-                let ibc_kinds: Vec<TransactionKindDb> = vec![
+                let ibc_kinds = [
                     TransactionKindDb::IbcTransparentTransfer,
                     TransactionKindDb::IbcShieldingTransfer,
                     TransactionKindDb::IbcUnshieldingTransfer,
diff --git a/webserver/src/service/transaction.rs b/webserver/src/service/transaction.rs
