Merge pull request #439 from namada-net/ian+tiago/recent-tx-filters

Add optional inner-tx kind and token filters to recent-wrappers endpoint#429

Author: Fraccaman

swagger.yml

@@ -878,6 +878,80 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/WrapperTransaction"
+  /api/v1/chain/wrapper/recent:
+    get:
+      summary: Get the most recent wrapper transactions with optional filtering by inner tx kind and/or transfer token
+      parameters:
+        - in: query
+          name: offset
+          schema:
+            type: integer
+            minimum: 0
+            maximum: 1000000
+            default: 0
+          description: Number of matching wrappers to skip (for pagination)
+        - in: query
+          name: size
+          schema:
+            type: integer
+            minimum: 10
+            maximum: 30
+            default: 10
+          description: Number of matching wrappers to return
+        - in: query
+          name: kind
+          schema:
+            type: array
+            items:
+              type: string
+              enum:
+                - "transparentTransfer"
+                - "shieldedTransfer"
+                - "shieldingTransfer"
+                - "unshieldingTransfer"
+                - "mixedTransfer"
+                - "bond"
+                - "redelegation"
+                - "unbond"
+                - "withdraw"
+                - "claimRewards"
+                - "voteProposal"
+                - "initProposal"
+                - "changeMetadata"
+                - "changeCommission"
+                - "revealPk"
+                - "ibcMsgTransfer"
+                - "ibcTransparentTransfer"
+                - "ibcShieldingTransfer"
+                - "ibcUnshieldingTransfer"
+                - "becomeValidator"
+                - "deactivateValidator"
+                - "reactivateValidator"
+                - "unjailValidator"
+                - "changeConsensusKey"
+                - "initAccount"
+                - "unknown"
+          style: form
+          explode: false
+          description: Optionally, filter by inner-tx kind(s) (comma-separated).
+        - in: query
+          name: token
+          schema:
+            type: array
+            items:
+              type: string
+          style: form
+          explode: false
+          description: Optionally, filter by inner-tx transfer token(s) (comma-separated). Using this filter will exclude non-transfer inner-tx kinds from the results. 
+      responses:
+        "200":
+          description: List of wrapper transactions with filtered inner transactions
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: "#/components/schemas/WrapperTransaction"
   /api/v1/chain/inner/{tx_id}:
     get:
       summary: Get the inner transaction by hash

webserver/src/dto/transaction.rs

@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 use subtle_encoding::hex;
 use validator::Validate;
 
+use crate::entity::transaction::TransactionKind;
 use crate::error::transaction::TransactionError;
 
 #[derive(Clone, Serialize, Deserialize, Validate)]
@@ -36,6 +37,12 @@ impl TransactionIdParam {
 #[derive(Clone, Serialize, Deserialize, Validate)]
 #[serde(rename_all = "camelCase")]
 pub struct TransactionMostRecentQueryParams {
+    #[validate(range(min = 0, max = 1000000))]
+    pub offset: Option<u64>,
     #[validate(range(min = 10, max = 30))]
     pub size: Option<u64>,
+    #[serde(default)]
+    pub kind: Vec<TransactionKind>,
+    #[serde(default)]
+    pub token: Vec<String>,
 }

webserver/src/entity/transaction.rs

@@ -3,10 +3,12 @@ use orm::transactions::{
     InnerTransactionDb, TransactionHistoryDb, TransactionHistoryKindDb,
     TransactionKindDb, TransactionResultDb, WrapperTransactionDb,
 };
+use serde::{Deserialize, Serialize};
 use shared::id::Id;
 use shared::token::{IbcToken, Token};
 
-#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub enum TransactionKind {
     TransparentTransfer,
     ShieldedTransfer,
@@ -75,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,

webserver/src/handler/transaction.rs

@@ -3,11 +3,14 @@ use axum::extract::{Path, State};
 use axum::http::HeaderMap;
 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,
 };
+use crate::entity::transaction::{InnerTransaction, TransactionKind};
 use crate::error::api::ApiError;
 use crate::error::transaction::TransactionError;
 use crate::response::headers;
@@ -103,32 +106,136 @@ pub async fn get_most_recent_transactions(
     Query(query): Query<TransactionMostRecentQueryParams>,
     State(state): State<CommonState>,
 ) -> Result<Json<Vec<WrapperTransactionResponse>>, ApiError> {
-    let size = query.size.unwrap_or(10);
-
-    let transactions = state
-        .transaction_service
-        .get_most_recent_transactions(size)
-        .await?;
-
-    let inner_txs = transactions
-        .iter()
-        .map(|tx| {
-            state
-                .transaction_service
-                .get_inner_tx_by_wrapper_id(tx.id.to_string())
+    let offset = query.offset.unwrap_or(0);
+    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();
+
+    let wrappers = if !filters_present {
+        state
+            .transaction_service
+            .get_most_recent_transactions(offset, size)
+            .await?
+    } else {
+        state
+            .transaction_service
+            .get_filtered_most_recent_wrappers(
+                offset,
+                size,
+                kind.clone(),
+                token.clone(),
+            )
+            .await?
+    };
+
+    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 = wrappers
+        .into_iter()
+        .zip(inner_results.into_iter())
+        .filter_map(|(tx, inner_res)| {
+            let mut inners = inner_res.unwrap_or_default();
+
+            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;
+                }
+            }
+
+            Some(WrapperTransactionResponse::new(tx, inners))
         })
         .collect::<Vec<_>>();
 
-    let inner_txs = futures::future::join_all(inner_txs).await;
+    Ok(Json(response))
+}
 
-    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();
+/// Filter a single inner transaction by token addresses involved (only
+/// applicable to transfer types)
+fn filter_inner_tx_by_tokens(
+    inner_tx: &InnerTransaction,
+    token_filter: &[String],
+) -> bool {
+    if token_filter.is_empty() {
+        return true;
+    }
 
-    Ok(Json(response))
+    let Some(data) = &inner_tx.data else {
+        return false;
+    };
+
+    let Ok(json_value) = serde_json::from_str::<serde_json::Value>(data) else {
+        return false;
+    };
+
+    // Check if a candidate token equals any of the filter tokens
+    let token_matches = |candidate: &str| -> bool {
+        token_filter
+            .iter()
+            .any(|filter_token| candidate.eq_ignore_ascii_case(filter_token))
+    };
+
+    // IBC transfers: data is an array; get token from [0].Ibc.address.Account
+    let is_ibc_kind = matches!(
+        inner_tx.kind,
+        TransactionKind::IbcTransparentTransfer
+            | TransactionKind::IbcShieldingTransfer
+            | TransactionKind::IbcUnshieldingTransfer
+    );
+
+    if is_ibc_kind {
+        if let Some(arr) = json_value.as_array() {
+            for item in arr {
+                if let Some(ibc_obj) = item.get("Ibc") {
+                    if let Some(account) = ibc_obj
+                        .get("address")
+                        .and_then(|a| a.get("Account"))
+                        .and_then(|a| a.as_str())
+                    {
+                        if token_matches(account) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+
+        // If structure differs unexpectedly, do not match
+        return false;
+    }
+
+    // Non-IBC transfers: check "sources" array containing entries with a
+    // "token" field
+    if let Some(obj) = json_value.as_object() {
+        if let Some(sources) = obj.get("sources").and_then(|v| v.as_array()) {
+            for src in sources {
+                if let Some(token_str) = src
+                    .as_object()
+                    .and_then(|o| o.get("token"))
+                    .and_then(|t| t.as_str())
+                {
+                    if token_matches(token_str) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+
+    false
 }