Fix DeFi replay crossed-tick drift

- Skip simulated tick-cross mutations after event-proven replay drift
- Keep swap fee accounting while anchoring tick, liquidity, and sqrt
- Add regression coverage for crossed-tick and fee-state invariants

Author: cjdsellers

crates/model/src/defi/pool_analysis/profiler.rs

@@ -315,36 +315,58 @@ impl PoolProfiler {
             .simulate_swap_through_ticks(amount_specified, zero_for_one, sqrt_price_limit_x96, true)
             .map_err(|e| Self::wrap_liquidity_error(e, location))?;
 
-        self.apply_swap_quote(&swap_quote);
+        let tick_mismatch = swap.tick != swap_quote.tick_after;
+        let liquidity_mismatch = swap.liquidity != swap_quote.liquidity_after;
+        let sqrt_mismatch = swap.sqrt_price_x96 != swap_quote.sqrt_price_after_x96;
+        let structural_mismatch = tick_mismatch || liquidity_mismatch;
+        if structural_mismatch && !swap_quote.crossed_ticks.is_empty() {
+            log::warn!(
+                "Replay swap simulation diverged after crossing {} ticks on block {}; anchoring event state without simulated tick-cross mutations",
+                swap_quote.crossed_ticks.len(),
+                swap.block
+            );
+            self.apply_swap_quote_without_crossed_ticks(&swap_quote);
+        } else {
+            self.apply_swap_quote(&swap_quote);
+        }
 
         // Verify simulation against event data - correct with event values if mismatch detected
-        if swap.tick != self.state.current_tick {
+        if tick_mismatch {
             log::warn!(
                 "Inconsistency in swap processing: Current tick mismatch: simulated {}, event {} on block {}",
-                self.state.current_tick,
+                swap_quote.tick_after,
                 swap.tick,
                 swap.block
             );
+        }
+
+        if swap.tick != self.state.current_tick {
             self.state.current_tick = swap.tick;
         }
 
-        if swap.liquidity != self.tick_map.liquidity {
+        if liquidity_mismatch {
             log::warn!(
                 "Inconsistency in swap processing: Active liquidity mismatch: simulated {}, event {} on block {}",
-                self.tick_map.liquidity,
+                swap_quote.liquidity_after,
                 swap.liquidity,
                 swap.block
             );
+        }
+
+        if swap.liquidity != self.tick_map.liquidity {
             self.tick_map.liquidity = swap.liquidity;
         }
 
-        if swap.sqrt_price_x96 != self.state.price_sqrt_ratio_x96 {
+        if sqrt_mismatch {
             log::warn!(
                 "Inconsistency in swap processing: Sqrt price mismatch: simulated {}, event {} on block {}",
-                self.state.price_sqrt_ratio_x96,
+                swap_quote.sqrt_price_after_x96,
                 swap.sqrt_price_x96,
                 swap.block
             );
+        }
+
+        if swap.sqrt_price_x96 != self.state.price_sqrt_ratio_x96 {
             self.state.price_sqrt_ratio_x96 = swap.sqrt_price_x96;
         }
 
@@ -641,13 +663,7 @@ impl PoolProfiler {
         self.state.current_tick = swap_quote.tick_after;
         self.state.price_sqrt_ratio_x96 = swap_quote.sqrt_price_after_x96;
 
-        if swap_quote.zero_for_one() {
-            self.state.fee_growth_global_0 = swap_quote.fee_growth_global_after;
-            self.state.protocol_fees_token0 += swap_quote.protocol_fee;
-        } else {
-            self.state.fee_growth_global_1 = swap_quote.fee_growth_global_after;
-            self.state.protocol_fees_token1 += swap_quote.protocol_fee;
-        }
+        self.apply_swap_quote_fee_state(swap_quote);
 
         for crossed in &swap_quote.crossed_ticks {
             let liquidity_net =
@@ -669,6 +685,23 @@ impl PoolProfiler {
         );
     }
 
+    fn apply_swap_quote_without_crossed_ticks(&mut self, swap_quote: &SwapQuote) {
+        self.state.current_tick = swap_quote.tick_after;
+        self.state.price_sqrt_ratio_x96 = swap_quote.sqrt_price_after_x96;
+        self.apply_swap_quote_fee_state(swap_quote);
+        self.analytics.total_swaps += 1;
+    }
+
+    fn apply_swap_quote_fee_state(&mut self, swap_quote: &SwapQuote) {
+        if swap_quote.zero_for_one() {
+            self.state.fee_growth_global_0 = swap_quote.fee_growth_global_after;
+            self.state.protocol_fees_token0 += swap_quote.protocol_fee;
+        } else {
+            self.state.fee_growth_global_1 = swap_quote.fee_growth_global_after;
+            self.state.protocol_fees_token1 += swap_quote.protocol_fee;
+        }
+    }
+
     /// Wraps a low-level [`LiquidityMathError`](super::error::LiquidityMathError) into a
     /// [`PoolProfilerError`] carrying the supplied event location, leaving non-liquidity
     /// errors untouched.

crates/model/src/defi/pool_analysis/tests.rs

@@ -828,6 +828,107 @@ fn test_process_swap_snaps_sqrt_price_to_event() {
     assert_eq!(profiler.state.price_sqrt_ratio_x96, event_sqrt_price);
 }
 
+#[rstest]
+fn test_process_swap_mismatch_does_not_mutate_simulated_crossed_tick() {
+    let mut actual_profiler = uni_pool_profiler();
+    actual_profiler
+        .process(&DexPoolData::FeeProtocolUpdate(create_fee_protocol_update(
+            6, 0,
+        )))
+        .unwrap();
+
+    let mut drifted_profiler = actual_profiler.clone();
+    let pool_identifier = actual_profiler.pool.pool_identifier;
+    let stale_upper_tick = -23040;
+    let stale_lower_tick = PoolTick::get_min_tick(TICK_SPACING);
+
+    drifted_profiler
+        .process(&DexPoolData::LiquidityUpdate(create_mint_event(
+            lp_address(),
+            stale_lower_tick,
+            stale_upper_tick,
+            50_000,
+        )))
+        .unwrap();
+
+    let stale_tick_before = *drifted_profiler
+        .get_tick(stale_upper_tick)
+        .expect("stale upper tick should exist");
+
+    let swap_quote = actual_profiler
+        .swap_exact_in(U256::from(expand_to_18_decimals(1)), true, None)
+        .unwrap();
+    assert!(swap_quote.crossed_ticks.is_empty());
+    assert!(swap_quote.tick_after < stale_upper_tick);
+
+    let swap_event = swap_quote.to_swap_event(
+        arbitrum(),
+        uniswap_v3(),
+        pool_identifier,
+        create_block_position(),
+        UnixNanos::default(),
+        UnixNanos::default(),
+        user_address(),
+        user_address(),
+    );
+    let amount_specified = swap_event.amount0;
+    let drifted_quote = drifted_profiler
+        .simulate_swap_through_ticks(amount_specified, true, swap_event.sqrt_price_x96, true)
+        .unwrap();
+    assert!(
+        drifted_quote
+            .crossed_ticks
+            .iter()
+            .any(|crossed| crossed.tick == stale_upper_tick)
+    );
+    assert_ne!(drifted_quote.liquidity_after, swap_event.liquidity);
+
+    let fee_growth_global_1_before = drifted_profiler.state.fee_growth_global_1;
+    let protocol_fees_token0_before = drifted_profiler.state.protocol_fees_token0;
+    let protocol_fees_token1_before = drifted_profiler.state.protocol_fees_token1;
+
+    drifted_profiler
+        .process(&DexPoolData::Swap(swap_event))
+        .unwrap();
+
+    let stale_tick_after = drifted_profiler
+        .get_tick(stale_upper_tick)
+        .expect("stale upper tick should remain");
+    assert_eq!(
+        stale_tick_after.fee_growth_outside_0,
+        stale_tick_before.fee_growth_outside_0
+    );
+    assert_eq!(
+        stale_tick_after.fee_growth_outside_1,
+        stale_tick_before.fee_growth_outside_1
+    );
+    assert_eq!(drifted_profiler.state.current_tick, swap_quote.tick_after);
+    assert_eq!(
+        drifted_profiler.state.price_sqrt_ratio_x96,
+        swap_quote.sqrt_price_after_x96
+    );
+    assert_eq!(
+        drifted_profiler.state.fee_growth_global_0,
+        drifted_quote.fee_growth_global_after
+    );
+    assert_eq!(
+        drifted_profiler.state.fee_growth_global_1,
+        fee_growth_global_1_before
+    );
+    assert_eq!(
+        drifted_profiler.state.protocol_fees_token0,
+        protocol_fees_token0_before + drifted_quote.protocol_fee
+    );
+    assert_eq!(
+        drifted_profiler.state.protocol_fees_token1,
+        protocol_fees_token1_before
+    );
+    assert_eq!(
+        drifted_profiler.tick_map.liquidity,
+        swap_quote.liquidity_after
+    );
+}
+
 #[rstest]
 fn test_set_fee_protocol_applies_to_state_and_snapshot(mut profiler: PoolProfiler) {
     let min_tick = PoolTick::get_min_tick(TICK_SPACING);