le test

Author: sug0

justfile

@@ -24,8 +24,8 @@ fmt-check:
 taplo:
     taplo fmt
 
-test:
-    cargo +{{ RUST_STABLE }} test
+test *ADDITIONAL_ARGS:
+    cargo +{{ RUST_STABLE }} test {{ ADDITIONAL_ARGS }}
 
 clippy:
     cargo +{{ RUST_STABLE }} clippy

shared/src/transaction.rs

@@ -397,7 +397,7 @@ impl InnerTransaction {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct Fee {
     pub gas: String,
     pub gas_used: Option<u64>,
@@ -659,7 +659,7 @@ fn extract_masp_transaction(
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub struct IbcSequence {
     pub sequence_number: String,
     pub source_port: String,

transactions/src/services/tx.rs

@@ -267,3 +267,121 @@ pub fn get_gas_estimates(
         })
         .collect()
 }
+
+#[cfg(test)]
+mod tests {
+    use namada_sdk::address::PGF;
+    use namada_sdk::ibc::apps::transfer::types::PrefixedCoin;
+    use namada_sdk::ibc::apps::transfer::types::packet::PacketData as Ics20PacketData;
+    use shared::block_result::{
+        Event, EventKind, IbcCorePacketKind, IbcPacket,
+    };
+    use shared::ser::{AccountsMap, TransferData};
+    use shared::token::Token;
+    use shared::transaction::TransactionExitStatus;
+
+    use super::*;
+
+    fn mock_block_result(
+        inner_tx_hash: Option<&str>,
+        with_packet_sender: Option<String>,
+    ) -> BlockResult {
+        BlockResult {
+            end_events: vec![Event {
+                kind: EventKind::IbcCore(IbcCorePacketKind::Send),
+                inner_tx_hash: inner_tx_hash
+                    .map(|hash| Id::Hash(hash.to_string())),
+                attributes: Some(TxAttributesType::SendPacket(IbcPacket {
+                    source_port: "transfer".to_string(),
+                    dest_port: "transfer".to_string(),
+                    source_channel: "channel-0".to_string(),
+                    dest_channel: "channel-0".to_string(),
+                    timeout_timestamp: 0,
+                    timeout_height: String::new(),
+                    sequence: "1".to_string(),
+                    data: with_packet_sender
+                        .map(|sender| {
+                            serde_json::to_string(&Ics20PacketData {
+                                token: PrefixedCoin {
+                                    denom: "eatshit".parse().unwrap(),
+                                    amount: "1234".parse().unwrap(),
+                                },
+                                sender: sender.into(),
+                                receiver: "a1aaaa".to_string().into(),
+                                memo: String::new().into(),
+                            })
+                            .unwrap()
+                        })
+                        .unwrap_or_default(),
+                })),
+            }],
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn test_get_ibc_packets() {
+        let expected_seq = |tx_id| IbcSequence {
+            sequence_number: "1".to_string(),
+            source_port: "transfer".to_string(),
+            dest_port: "transfer".to_string(),
+            source_channel: "channel-0".to_string(),
+            dest_channel: "channel-0".to_string(),
+            timeout: 0,
+            tx_id,
+        };
+
+        // get ibc seq just from the events + inner tx hash
+        let block_result = mock_block_result(Some("deadbeef"), None);
+        assert_eq!(
+            get_ibc_packets(&block_result, &[]),
+            vec![expected_seq(Id::Hash("deadbeef".to_string()))],
+        );
+
+        // protocol transfer, there is no inner tx hash
+        let block_result = mock_block_result(None, Some(PGF.to_string()));
+        assert_eq!(
+            get_ibc_packets(&block_result, &[]),
+            vec![expected_seq(Id::Hash(
+                Hash::sha256("transfer/channel-0/transfer/channel-0/1")
+                    .to_string()
+                    .to_lowercase()
+            ))],
+        );
+
+        // no inner tx hash in the event, get it from the provided tx slice
+        let block_result = mock_block_result(None, Some("a1aaaa".to_string()));
+        let wrapper = WrapperTransaction {
+            exit_code: TransactionExitStatus::Applied,
+            tx_id: Id::Hash("eatshit".to_string()),
+            index: 0,
+            fee: Default::default(),
+            atomic: false,
+            block_height: 0,
+            total_signatures: 0,
+            size: 0,
+        };
+        let inner = InnerTransaction {
+            tx_id: Id::Hash("deadbeef".to_string()),
+            wrapper_id: Id::Hash("eatshit".to_string()),
+            index: 0,
+            kind: TransactionKind::IbcSendTrasparentTransfer((
+                Token::Native(Id::Hash("aabbcc".to_string())),
+                TransferData {
+                    sources: AccountsMap(Default::default()),
+                    targets: AccountsMap(Default::default()),
+                    shielded_section_hash: None,
+                },
+            )),
+            data: None,
+            extra_sections: Default::default(),
+            memo: None,
+            notes: 0,
+            exit_code: TransactionExitStatus::Applied,
+        };
+        assert_eq!(
+            get_ibc_packets(&block_result, &[(wrapper, vec![inner])]),
+            vec![expected_seq(Id::Hash("deadbeef".to_string()))],
+        );
+    }
+}