feat: integration test against given cpi event

Author: nooma-42

.gitignore

@@ -1,5 +1,6 @@
 target/
 crates/mock/fixtures
+tests/fixtures
 *.env*
 Vixen.toml
 Vixen.test.toml

tests/common/mod.rs

@@ -4,8 +4,20 @@ use std::{path::PathBuf, time::Duration};
 
 use tokio::sync::broadcast;
 use yellowstone_vixen::config::{BufferConfig, VixenConfig};
+use yellowstone_vixen_mock::{
+    create_mock_transaction_update_with_cache, parse_instructions_from_txn_update,
+};
 use yellowstone_vixen_yellowstone_grpc_source::YellowstoneGrpcConfig;
 
+/// Trait for CPI events that can be parsed from instruction data and have token changes
+pub trait CpiEventParseable {
+    fn from_inner_instruction_data(data: &[u8]) -> Option<Self>
+    where
+        Self: Sized;
+    fn source_token_change(&self) -> u64;
+    fn destination_token_change(&self) -> u64;
+}
+
 /// Command line options for integration tests
 #[derive(clap::Parser, Debug)]
 #[command(version, author, about = "Yellowstone Vixen Integration Tests")]
@@ -179,3 +191,100 @@ where
         }
     }
 }
+
+/// Asserts that a CPI event at the specified instruction indices has the expected token changes.
+///
+/// # Arguments
+/// * `signature` - Transaction signature to fetch and parse
+/// * `ix_path` - Path of instruction indices: [top_level, inner, nested_inner, ...]
+/// * `expected_source_token_change` - Expected source token change value
+/// * `expected_destination_token_change` - Expected destination token change value
+///
+/// # Example
+/// ```ignore
+/// // 2-level: top-level #6 → inner #5
+/// assert_okx_dex_v2_cpi_event_token_changes::<SwapCpiEvent2>(sig, &[6, 5], 100, 200).await?;
+///
+/// // 3-level: top-level #3 → inner #2 → nested #8
+/// assert_okx_dex_v2_cpi_event_token_changes::<SwapCpiEvent2>(sig, &[3, 2, 8], 100, 200).await?;
+/// ```
+pub async fn assert_okx_dex_v2_cpi_event_token_changes<T: CpiEventParseable>(
+    signature: &str,
+    ix_path: &[usize],
+    expected_source_token_change: u64,
+    expected_destination_token_change: u64,
+) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    assert!(
+        ix_path.len() >= 2,
+        "ix_path must have at least 2 indices (top-level and inner)"
+    );
+
+    let txn_update = create_mock_transaction_update_with_cache(signature)
+        .await
+        .expect("Failed to fetch transaction");
+
+    let instruction_updates =
+        parse_instructions_from_txn_update(&txn_update).expect("Failed to parse instructions");
+
+    let top_level_ix = instruction_updates
+        .get(ix_path[0])
+        .ok_or_else(|| format!("Top-level instruction index {} not found", ix_path[0]))?;
+
+    // Navigate through the inner instruction path
+    let mut current_inner = top_level_ix
+        .inner
+        .get(ix_path[1])
+        .ok_or_else(|| format!("Inner instruction index {} not found", ix_path[1]))?;
+
+    for (depth, &idx) in ix_path.iter().enumerate().skip(2) {
+        current_inner = current_inner.inner.get(idx).ok_or_else(|| {
+            format!(
+                "Nested instruction index {} at depth {} not found",
+                idx, depth
+            )
+        })?;
+    }
+
+    let event = T::from_inner_instruction_data(&current_inner.data)
+        .ok_or("Failed to parse CPI event from instruction data")?;
+
+    assert_eq!(
+        event.source_token_change(),
+        expected_source_token_change,
+        "source_token_change mismatch"
+    );
+    assert_eq!(
+        event.destination_token_change(),
+        expected_destination_token_change,
+        "destination_token_change mismatch"
+    );
+
+    Ok(())
+}
+
+// Macro to implement CpiEventParseable for multiple types
+macro_rules! impl_cpi_event_parseable {
+    ($($ty:ty),+ $(,)?) => {
+        $(
+            impl CpiEventParseable for $ty {
+                fn from_inner_instruction_data(data: &[u8]) -> Option<Self> {
+                    Self::from_inner_instruction_data(data)
+                }
+                fn source_token_change(&self) -> u64 {
+                    self.source_token_change
+                }
+                fn destination_token_change(&self) -> u64 {
+                    self.destination_token_change
+                }
+            }
+        )+
+    };
+}
+
+impl_cpi_event_parseable!(
+    yellowstone_vixen_okx_dex_v2_parser::types::SwapCpiEvent2,
+    yellowstone_vixen_okx_dex_v2_parser::types::SwapWithFeesCpiEvent2,
+    yellowstone_vixen_okx_dex_v2_parser::types::SwapWithFeesCpiEventEnhanced,
+    yellowstone_vixen_okx_dex_v2_parser::types::SwapTobV2CpiEvent2,
+    yellowstone_vixen_okx_dex_v2_parser::types::SwapTocV2CpiEvent2,
+);

tests/integration_test.rs

@@ -509,3 +509,83 @@ async fn test_raydium_launchpad_specific_signatures(
     let parser = RaydiumLaunchpadInstructionParser;
     test_specific_signatures("Raydium Launchpad", &parser, signatures).await
 }
+
+/// Test OKX DEX v2 CPI event parsing from a specific transaction
+/// test all ix in [README.md](../crates/kryptogo-vixen-okx-dex-v2-parser/README.md)
+///
+/// NOTE:
+/// Use helius explorer (Orb) to see the logs for the transaction and find out inner instruction index.
+/// Solscan or Orb instruction page don't show inner instruction nested level
+/// cross reference instruction page with Solscan or Orb to find out which CPI event is the one we want to test.
+/// https://orbmarkets.io/tx/3Rrgt5ABbfUNoqerVQNCjfQYwafnSm3VNgmtB31aZ4y11Rc4FSHjdMzrXSkyquNnFVp8NAjrU1fAk6ero1cbw59q?tab=logs
+///
+/// For example i want to test last inner instruction (CPI event, Invoking OKX DEX Router Program) of top-level instruction (Invoking OKX DEX Router Program)
+/// top-level ix index to 6 and inner ix index to 6.
+/// The index on instruction page is 1-indexed, all index must minus 1.
+///
+/// You need to manually fill in the ix path and expected token changes and type of CPI event.
+/// You should add non existent type in impl_cpi_event_parseable
+#[tokio::test]
+async fn test_okx_dex_v2_cpi_event_parsing() {
+    use yellowstone_vixen_okx_dex_v2_parser::types::{
+        SwapCpiEvent2, SwapTocV2CpiEvent2, SwapWithFeesCpiEvent2, SwapWithFeesCpiEventEnhanced,
+    };
+
+    common::assert_okx_dex_v2_cpi_event_token_changes::<SwapCpiEvent2>(
+        "4XfXNQABC7igdCgtux9dXDb6Dj8VzxBQb5JzgpNdy3ajKdnMbRfiZbywfbuoQTvQ3XCHdBvPBSCCqzDKaenHETVY",
+        &[3, 3], // top-level #3 → inner #3
+        2000500000,
+        295045121,
+    )
+    .await
+    .expect("Swap CPI event parsing test failed");
+
+    // ProxySwap no real tx yet
+
+    common::assert_okx_dex_v2_cpi_event_token_changes::<SwapWithFeesCpiEvent2>(
+        "3Rrgt5ABbfUNoqerVQNCjfQYwafnSm3VNgmtB31aZ4y11Rc4FSHjdMzrXSkyquNnFVp8NAjrU1fAk6ero1cbw59q",
+        &[6, 6], // top-level #6 → inner #6
+        10000000,
+        14918710783,
+    )
+    .await
+    .expect("SwapTob CPI event parsing test failed");
+
+    common::assert_okx_dex_v2_cpi_event_token_changes::<SwapWithFeesCpiEventEnhanced>(
+        "2wpzTEZzyWgC9ZTHMmppcdVwKDdCE1owBby1cFPNKB2S6XWW4sc4w3mxgDq4N1Z5bhzAGhLQqk6qMDCrVEi5RVhc",
+        &[6, 10], // top-level #6 → inner #10
+        1000000,
+        5699503,
+    )
+    .await
+    .expect("SwapTobEnhanced CPI event parsing test failed");
+
+    // SwapTobV2 no real tx yet
+
+    common::assert_okx_dex_v2_cpi_event_token_changes::<SwapWithFeesCpiEvent2>(
+        "5H5SLPoNyvKjSQfUfiu3PxMKiqfejMh6wuge2TmteRJc6jGxW77XzbiQsvcd9y5zGrfkQ8E7cATepgTHkTu19shp",
+        &[3, 2, 9],
+        4675790000,
+        115187775,
+    )
+    .await
+    .expect("SwapTobWithReceiver CPI event parsing test failed");
+
+    common::assert_okx_dex_v2_cpi_event_token_changes::<SwapWithFeesCpiEvent2>(
+        "X41pjVYMdoZd15v1AnHpqV9sGspTEBfzhJ6uk95X2tdthxnQCiGDz5iLfdkhhPfV6cNX14Jpqivq5wmonDudDMi",
+        &[4, 8],
+        1191877137296814,
+        7968827164,
+    )
+    .await
+    .expect("SwapToc CPI event parsing test failed");
+
+    common::assert_okx_dex_v2_cpi_event_token_changes::<SwapTocV2CpiEvent2>(
+        "37DzX3osK9x5jKsCZnZHtkLopf3xmEekHDubpUBd9dVxPy9yCF9TWzvy5rLNSFnM9FyqnE9LeYyGDRvs4hdXmajc",
+        &[7, 8],
+        1986400000,
+        224645346850,
+    )
+    .await
+    .expect("SwapTocV2 CPI event parsing test failed");
+}