chore(ICP-Rosetta): FI-1479: fix search transactions endpoint

rs/rosetta-api/Cargo.toml

@@ -42,6 +42,7 @@ reqwest = { workspace = true }
 rolling-file = { workspace = true }
 rosetta-core = { path = "rosetta_core" }
 serde = { workspace = true }
+serde_bytes = { workspace = true }
 serde_cbor = { workspace = true }
 serde_json = { workspace = true }
 strum = { workspace = true }
@@ -52,7 +53,6 @@ tracing-appender = { workspace = true }
 tracing-subscriber = { workspace = true }
 url = { workspace = true }
 rusqlite = { version = "~0.28.0", features = ["bundled"] }
-serde_bytes = { workspace = true }
 
 [dev-dependencies]
 futures = { workspace = true }

rs/rosetta-api/src/request_handler.rs

@@ -804,7 +804,7 @@ impl RosettaRequestHandler {
         // Sort the transactions by block index in descending order
         transactions.sort_by(|a, b| b.block_identifier.index.cmp(&a.block_identifier.index));
 
-        // Is rosetta blocks is empty that means the entire blockchain was traversed but no transactions were found that match the search criteria
+        // If rosetta blocks is empty that means the entire blockchain was traversed but no transactions were found that match the search criteria
         let last_traversed_block_index = blocks.iter().map(|block| block.index).min().unwrap_or(0);
         let num_fetched_transactions = transactions.len();
 

rs/rosetta-api/tests/system_tests/system_tests.rs

@@ -18,19 +18,3 @@ fn smoke_test() {
         assert_eq!(res.network_identifiers.len(), 1);
     });
 }
-
-#[test]
-fn test_cc() {
-    println!(
-        "Acc: {:?}",
-        icp_ledger::AccountIdentifier::new(
-            ic_types::PrincipalId(
-                candid::Principal::from_text(
-                    "iowfl-yzooa-br3dt-77erl-nlm7f-kplhq-php75-hw3an-aeqn2-swh4t-3qe",
-                )
-                .unwrap(),
-            ),
-            None,
-        )
-    );
-}

rs/rosetta-api/tests/system_tests/test_cases/search_transactions.rs

@@ -16,6 +16,7 @@ use proptest::test_runner::TestRunner;
 use rosetta_core::identifiers::TransactionIdentifier;
 use rosetta_core::objects::BlockTransaction;
 use rosetta_core::request_types::SearchTransactionsRequest;
+use std::collections::HashMap;
 use std::collections::HashSet;
 use std::sync::Arc;
 use std::time::SystemTime;
@@ -313,8 +314,10 @@ fn test_search_transactions_by_account() {
                             // Make sure every fetched transaction is unique
                             assert_eq!(
                                 result.len(),
-                                result.into_iter().collect::<HashSet<_>>().len()
+                                result.clone().into_iter().collect::<HashSet<_>>().len()
                             );
+
+                            assert!(!result.is_empty());
                         }
 
                         search_transactions_request.account_identifier = Some(
@@ -366,20 +369,34 @@ fn test_search_transactions_by_operation_type() {
                         .await;
 
                     if !args_with_caller.is_empty() {
-                        let operations = vec![
-                            "TRANSFER".to_string(),
-                            "MINT".to_string(),
-                            "BURN".to_string(),
-                            "APPROVE".to_string(),
-                        ];
-
                         let mut search_transactions_request =
                             SearchTransactionsRequest::builder(env.network_identifier.clone())
                                 .build();
-
-                        for operation in operations.into_iter() {
+                        let icp_blocks = query_encoded_blocks(
+                            &get_test_agent(env.pocket_ic.url().unwrap().port().unwrap()).await,
+                            0,
+                            u64::MAX,
+                        )
+                        .await
+                        .blocks
+                        .into_iter()
+                        .map(|block| icp_ledger::Block::decode(block).unwrap())
+                        .collect::<Vec<icp_ledger::Block>>();
+                        let operation_counts =
+                            icp_blocks.iter().fold(HashMap::new(), |mut ops, s| {
+                                let ops_type = match s.transaction.operation {
+                                    icp_ledger::Operation::Transfer { .. } => "Transfer",
+                                    icp_ledger::Operation::Mint { .. } => "Mint",
+                                    icp_ledger::Operation::Burn { .. } => "Burn",
+                                    icp_ledger::Operation::Approve { .. } => "Approve",
+                                }
+                                .to_string();
+                                *ops.entry(ops_type).or_insert(0) += 1;
+                                ops
+                            });
+                        for operation in operation_counts.keys().clone() {
                             // We make sure that the service returns the correct number of transactions for each account
-                            search_transactions_request.type_ = Some(operation);
+                            search_transactions_request.type_ = Some(operation.clone());
 
                             let result = traverse_all_transactions(
                                 &env.rosetta_client,
@@ -389,17 +406,27 @@ fn test_search_transactions_by_operation_type() {
                             assert!(result.clone().into_iter().all(|block_transaction| {
                                 block_transaction.transaction.operations.into_iter().any(
                                     |operation| {
-                                        operation.type_
-                                            == search_transactions_request.type_.clone().unwrap()
+                                        // ICP Rosetta returns Transfers as Transactions and not as Transfer
+                                        if operation.type_ == "TRANSACTION" {
+                                            search_transactions_request.type_
+                                                == Some("Transfer".to_string())
+                                        } else {
+                                            search_transactions_request
+                                                .type_
+                                                .clone()
+                                                .map(|t| t.to_uppercase())
+                                                == Some(operation.type_)
+                                        }
                                     },
                                 )
                             }));
 
                             // Make sure every fetched transaction is unique
                             assert_eq!(
                                 result.len(),
-                                result.into_iter().collect::<HashSet<_>>().len()
+                                result.clone().into_iter().collect::<HashSet<_>>().len()
                             );
+                            assert_eq!(result.len(), *operation_counts.get(operation).unwrap());
                         }
 
                         search_transactions_request.type_ = Some("INVALID_OPERATION".to_string());
@@ -408,7 +435,7 @@ fn test_search_transactions_by_operation_type() {
                             search_transactions_request.clone(),
                         )
                         .await;
-                        // If the account does not exist the service should return an empty list
+                        // If the operation type does not exist the service should return an empty list
                         assert_eq!(result.len(), 0);
                     }
                 });