kestrel-chartkit 0.1.1

High-performance Rust technical analysis library for indicator math, market regime classification, composite scoring, and SVG visualization.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use std::collections::HashMap;

use crate::indicator::{Indicator, IndicatorAlert, IndicatorOutput};
use crate::model::Bar;

/// Smart Money Fair Value Gap (FVG) & Liquidity Sweep Engine.
/// Detects institutional price imbalances and liquidity pool sweeps.
pub struct LiquidityFvgEngine {
    lookback: usize,
    window: Vec<Bar>,
    alerts: Vec<IndicatorAlert>,
}

impl LiquidityFvgEngine {
    pub fn new(lookback: usize) -> Self {
        Self {
            lookback,
            window: Vec::with_capacity(lookback + 5),
            alerts: Vec::new(),
        }
    }
}

impl Indicator for LiquidityFvgEngine {
    fn name(&self) -> &str {
        "liquidity_fvg"
    }

    fn warmup_period(&self) -> usize {
        self.lookback.max(3)
    }

    fn reset(&mut self) {
        self.window.clear();
        self.alerts.clear();
    }

    fn on_bar(&mut self, bar: &Bar) -> Option<IndicatorOutput> {
        self.window.push(bar.clone());
        if self.window.len() > self.lookback + 5 {
            self.window.remove(0);
        }

        self.alerts.clear();

        if self.window.len() < 3 {
            return Some(IndicatorOutput::new(0.0));
        }

        let n = self.window.len();
        let curr = &self.window[n - 1];
        let prev2 = &self.window[n - 3];

        let mut fvg_type = 0.0f64;
        let mut gap_size = 0.0f64;

        // 1. Bullish Fair Value Gap (Low[t] > High[t-2])
        if curr.low > prev2.high {
            fvg_type = 1.0;
            gap_size = curr.low - prev2.high;
            self.alerts.push(IndicatorAlert::new(
                "bullish_fvg",
                format!(
                    "Bullish Fair Value Gap (FVG Zone ${:.2} - ${:.2})",
                    prev2.high, curr.low
                ),
                0.85,
            ));
        }
        // 2. Bearish Fair Value Gap (High[t] < Low[t-2])
        else if curr.high < prev2.low {
            fvg_type = -1.0;
            gap_size = prev2.low - curr.high;
            self.alerts.push(IndicatorAlert::new(
                "bearish_fvg",
                format!(
                    "Bearish Fair Value Gap (FVG Zone ${:.2} - ${:.2})",
                    curr.high, prev2.low
                ),
                0.85,
            ));
        }

        // 3. Liquidity Sweep Detection over lookback window
        if n > self.lookback {
            let prev_bars = &self.window[n - 1 - self.lookback..n - 1];
            let recent_highest = prev_bars
                .iter()
                .map(|b| b.high)
                .fold(f64::NEG_INFINITY, f64::max);
            let recent_lowest = prev_bars
                .iter()
                .map(|b| b.low)
                .fold(f64::INFINITY, f64::min);

            // Bullish Liquidity Sweep (Low pierced recent lowest, but Close > recent lowest)
            if curr.low < recent_lowest && curr.close > recent_lowest {
                self.alerts.push(IndicatorAlert::new(
                    "bullish_liquidity_sweep",
                    format!(
                        "Bullish Liquidity Sweep (Pierced ${:.2} Support, Reclaimed Close)",
                        recent_lowest
                    ),
                    0.95,
                ));
            }
            // Bearish Liquidity Sweep (High pierced recent highest, but Close < recent highest)
            else if curr.high > recent_highest && curr.close < recent_highest {
                self.alerts.push(IndicatorAlert::new(
                    "bearish_liquidity_sweep",
                    format!(
                        "Bearish Liquidity Sweep (Pierced ${:.2} Resistance, Reclaimed Close)",
                        recent_highest
                    ),
                    0.95,
                ));
            }
        }

        let mut extra = HashMap::new();
        extra.insert("fvg_type".to_string(), fvg_type);
        extra.insert("gap_size".to_string(), gap_size);

        Some(IndicatorOutput::with_extra(fvg_type, extra))
    }

    fn alerts(&self) -> Vec<IndicatorAlert> {
        self.alerts.clone()
    }
}

pub fn build_liquidity_fvg(params: &HashMap<String, f64>) -> LiquidityFvgEngine {
    let lookback = params.get("lookback").copied().unwrap_or(20.0) as usize;
    LiquidityFvgEngine::new(lookback)
}