Volume Channel Flow [ChartPrime]⯁ OVERVIEW — Volume Channel Flow
The Volume Channel Flow indicator dynamically tracks evolving trend channels while simultaneously analyzing volume distribution within each channel segment.
By combining adaptive volatility-based channel boundaries with real-time volume profiling, the tool highlights directional bias, structural breakouts, and zones where buy/sell pressure is concentrated.
This makes it a powerful hybrid of a trend-tracking system and a miniature volume-profile engine that updates live as the market moves.
⯁ CONCEPTS
Dynamic Volatility Channel:
Upper and lower channel levels are continuously recalculated using ATR. These levels shift only when price breaks outside the previous channel, signaling a trend transition.
Channel Segmentation:
When a channel shift occurs, the previous segment is closed and visually plotted as its own range — allowing traders to inspect each discrete “flow phase” of the market.
Embedded Volume Profile:
Inside each channel segment, the indicator builds a mini volume histogram using user-defined binning. This creates a quick visual read of how volume was distributed within that price range.
Point of Control (PoC):
The price level with the highest traded volume inside each completed segment is detected and plotted as a dashed horizontal PoC line.
Flow Bias (Bullish/Bearish):
The volume profile color adapts depending on whether cumulative delta volume (buy minus sell pressure) is positive or negative for the segment.
Breakout Labels:
When a new channel is formed, arrows mark whether the breakout occurred upward or downward.
⯁ FEATURES
Adaptive Trend Channel Construction
Channels update only when price closes beyond upper or lower volatility thresholds. This isolates trend shifts with minimal noise.
Channel Visualization Options
Choose to display full channel boxes or only trend lines using customizable styling.
Real-Time Volume Profiling
As long as the channel remains active, volume distribution is recalculated live on every bar.
PoC Projection
The PoC is drawn across the channel range, marking the highest-volume price level for each segment.
Directional Delta Coloring
Volume profiles automatically shift to bullish or bearish colors based on cumulative delta inside the channel.
Breakout Detection
Arrows highlight each transition into a new channel regime.
⯁ HOW TO USE
Spot trend changes using breakout arrows and the creation of new trend channels.
Gauge strength of a channel by examining the density and shape of the internal volume profile.
Use PoC levels as potential support/resistance interaction zones.
Validate momentum by checking whether volume delta shows bullish or bearish dominance.
Monitor channel edges to anticipate continuation or reversal setups.
⯁ CONCLUSION
The Volume Channel Flow indicator merges trend structure with volume analytics, providing a continuously adaptive picture of market flow.
It not only detects where trend phases begin and end, but also reveals what type of volume behavior shaped each segment, offering a deeper understanding of trend strength and directional pressure.
Indicators and strategies
Kalman Hull Trend Score [BackQuant]Kalman Hull Trend Score
Overview
Kalman Hull Trend Score is a trend-strength and regime-evaluation indicator that combines two ideas, Kalman filtering and Hull-style smoothing, then measures persistence of that filtered trend using a rolling score. The goal is to produce a cleaner, more stable trend read than typical moving average tools, while still reacting fast enough to be practical in live markets.
Instead of treating a moving average as a simple line you cross, this indicator turns the filtered trend into an oscillator-like score that answers: “Is the smoothed trend consistently progressing, or is it stalling and degrading?”
Core idea
The indicator is built from two components:
A Kalman-based smoothing engine that estimates price state and reduces noise adaptively.
A Hull-style construction that uses multiple Kalman passes to create a responsive, low-lag trend filter.
Once the Kalman Hull filter is built, a persistence score is calculated by comparing the current Kalman Hull value to many past values. The result is a trend score that rises in sustained trends and compresses or flips during deterioration.
Why Kalman instead of standard smoothing
Traditional moving averages apply fixed smoothing rules regardless of market conditions. A Kalman filter behaves differently, it is designed to estimate an underlying state in noisy data, adjusting how much it “trusts” new price information versus prior estimates.
This script exposes that behavior through two key controls:
Measurement Noise: how noisy the observed price is assumed to be.
Process Noise: how much the underlying state is allowed to evolve from bar to bar.
Together, these settings let you tune the balance between smoothness and responsiveness without relying on blunt averaging alone.
Kalman filter mechanics (conceptual)
Each update cycle follows the classic structure:
Prediction: assume the state continues, and expand uncertainty by process noise.
Update: compute Kalman Gain, then blend the new price observation into the estimate.
Correction: reduce uncertainty based on how much the filter accepted the new information.
When measurement noise is higher, the filter becomes more conservative, smoothing harder. When process noise is higher, the filter adapts faster to regime changes, but can become more reactive.
Check out the original script:
Kalman Hull construction
The “Hull” component is not a standard HMA built from WMAs. Instead, it recreates the Hull idea using Kalman filtering as the smoothing primitive. The structure follows the same intent as HMA, reduce lag while keeping the line smooth, but does it with Kalman passes:
Apply Kalman smoothing over multiple effective lengths.
Combine them using the Hull-style weighting logic.
Run the combined output through another Kalman pass to finalize smoothing.
The result is a Kalman Hull filter that aims to track trend with less jitter than raw price, and less lag than slow averages.
Another Kalman Hull with Supertrend
Trend scoring logic
The trend score is computed by comparing the current Kalman Hull value to past Kalman Hull values over a fixed lookback range (1 to 45 bars in this script):
If current kalmanHMA > kalmanHMA , add +1
If current kalmanHMA < kalmanHMA , add -1
This produces a persistence score rather than a simple direction signal. Strong trends where the filter keeps advancing will accumulate positive comparisons. Weak trends, chop, or reversals will cause the score to flatten, decay, or flip negative.
Interpreting the score
Read the score as trend conviction and persistence:
High positive values: bullish persistence, the filtered trend is progressing consistently.
Low positive values: trend exists but is fragile, progress is slowing.
Near zero: indecision, range behavior, frequent challenges to structure.
Negative values: bearish persistence or sustained deterioration in the filtered trend.
The rate of change matters:
Score expansion suggests trend is gaining traction.
Score compression often signals consolidation or exhaustion.
Fast flips usually accompany regime transitions.
Signal thresholds and regime transitions
User-defined thresholds convert the score into regimes:
Long threshold: score must exceed this level to confirm bullish persistence.
Short threshold: a crossunder of the score triggers bearish regime transition.
This is intentionally conservative. Long bias is maintained while the score holds above the long threshold. Short transitions are event-triggered on breakdown via crossunder, helping avoid constant flipping during minor noise.
Signals are only plotted on regime changes (first bar of the flip), keeping them clean for alerts and backtests.
Visual presentation
The indicator provides multiple layers depending on how you want to use it:
Kalman Hull Trend Score oscillator, color-coded by active regime.
Optional Kalman Hull filter plotted on the price chart for structure context.
Optional threshold reference lines for quick regime mapping.
Optional candle coloring and background shading for instant readability.
You can run it as a pure score panel or as a combined panel + on-chart trend overlay.
How to use in practice
Trend filtering
Favor long setups when the score remains above the long threshold.
Reduce directional aggression when score compresses toward zero.
Treat a short-threshold breakdown as a regime risk event, not just a signal.
Trend quality assessment
Rising score supports continuation trades and adds confidence to breakouts.
Flat or falling score warns that trend persistence is fading.
If price trends but score fails to expand, trend may be weak or liquidity-driven.
Trade management
Use the Kalman Hull line as dynamic structure reference on chart.
Use score deterioration to scale out before a full regime flip.
Use regime flips as confirmation for bias shifts rather than prediction.
Tuning guidelines
Measurement Noise
Higher: smoother filter, fewer false shifts, slower to adapt.
Lower: more responsive, more sensitive to microstructure noise.
Process Noise
Higher: adapts quicker to sudden changes, but can become twitchy.
Lower: steadier state estimate, but slower during sharp regime transitions.
A practical approach is to first tune measurement noise until the Kalman Hull line matches the “clean trend structure” you want, then adjust process noise to control how quickly it reacts when the regime genuinely changes.
Summary
Kalman Hull Trend Score transforms a Kalman-based Hull-style trend filter into a quantified persistence oscillator. By combining adaptive Kalman smoothing with low-lag Hull logic and a rolling comparison score, it provides a cleaner read on trend quality than basic moving averages or single-condition trend tools. It is best used as a regime filter, trend strength gauge, and structure-aware trade management layer.
Range Indicator Golden Pocket, Liquidity, FairValueGapOverview
This indicator is a comprehensive institutional market structure toolkit. It is designed to identify high-probability reversal zones by merging three powerful technical analysis concepts: Fibonacci Golden Pockets (61.8% - 65%), Liquidity Pool Analysis (Swing Failure Patterns), and Fair Value Gaps (FVG). By automating the detection of price inefficiencies and "stop runs," it helps traders navigate complex price action with objective, rule-based confirmation.
What the Script Does
The script continuously monitors a user-defined lookback period to define a trading range. Within this range, it dynamically plots:
Golden Pockets: High-confluence retracement zones (calculated as 0.35 - 0.382 internal range levels).
Liquidity Zones: Highlighted regions at the absolute high and low (Top/Bottom 5%) where institutional orders and retail stops are typically concentrated.
Swing Failure Patterns (SFP): Real-time detection of liquidity grabs where price breaches a range extreme but fails to close outside, signaling a potential trap.
Fair Value Gaps (FVG): Visualizes 3-candle price imbalances, showing areas of aggressive buying or selling that often act as future magnets or support/resistance.
2-Candle Confirmation: A momentum-based filter requiring a candle-close confirmation before a reversal signal is generated.
For Whom is it?
Smart Money Concepts (SMC) & ICT Students: Traders looking for automated liquidity sweeps and market inefficiencies.
Fibonacci & Mean Reversion Traders: Those seeking a clean, professional visualization of the Golden Pocket across multiple timeframes.
Systematic Day Traders: Who require strict price-action confirmation (SFP and 2-candle rules) to remove emotional bias from their entries.
Functions and Input Options
1. Market Structure & Visuals
Lookback Period (Default: 100): Defines the window for calculating the range extremes.
Box Offset Right (Default: 50): Extends all zones into the future for better anticipatory trading.
Show Price Lines & Labels: Displays the exact price for every zone boundary on the right axis for precise execution.
2. Fair Value Gap (FVG) Settings
Show Fair Value Gaps: A toggle to enable/disable the plotting of price imbalances.
FVG Extension (Default: 10): Determines how many bars into the future the FVG box remains visible.
Custom Colors: Separate color inputs for Bullish (Gap Up) and Bearish (Gap Down) inefficiencies.
3. Professional Alert System
The script includes five specific alert conditions:
GP Touch: Early warning when price enters a Golden Pocket.
2-Candle Pattern: Confirmed momentum shift within a Golden Pocket.
SFP Long/Short: Alerts when a Liquidity Grab (Swing Failure) is confirmed at the range high or low.
Transparency and Compliance (Moderator Info)
Non-Repainting Logic: All signals (SFP, 2-Candle, and FVG) are calculated and triggered based on confirmed candle closes. Drawings use barstate.islast purely for visual efficiency without altering historical data integrity.
Educational Context: The script visualizes well-known market principles (Fibonacci, SFPs, and FVGs) to aid traders in their analysis; it does not provide automated financial advice or "black-box" buy/sell signals.
Resource Management: Optimized for Pine Script v5, using efficient array and box handling to ensure smooth performance even on lower timeframes.
Wave Dynamics - Neural Adaptive Engine🌊 WAVE DYNAMICS - NEURAL ADAPTIVE ENGINE
The Official Reference Manual & Trading Protocol
═════════════════════════════════════════════════════════════
📖 PREFACE: THE END OF STATIC ANALYSIS
The financial markets are not linear; they are fractal. They do not move in straight lines; they breathe. They expand in trending volatility and contract in chopping noise.
The fundamental failure of traditional technical analysis is Static Sensitivity .
• A 14-period RSI works beautifully in a range but fails in a trend.
• A 12,26 MACD captures trends but destroys capital in chop.
Wave Dynamics solves this by treating the market as a living organism. At its core is a Neural Adaptive Engine that calculates the Hurst Exponent (Fractal Dimension) in real-time. It measures the "roughness" of price action and automatically adjusts the lookback periods of every subsystem—Waves, Ribbons, and Oscillators—to match the current market regime.
This manual is your guide to navigating this adaptive framework.
PART 1: THEOLOGY & MARKET PHYSICS
To use this tool, you must understand the three pillars of its logic:
1. The Hurst Exponent (Chaos Theory)
The engine continuously calculates H (Hurst) on a rolling window.
• Persistent Regime (H > 0.5): "What is happening now is likely to continue." The market is trending. The Engine Tightens sensitivity to catch fast pullbacks.
• Anti-Persistent Regime (H < 0.5): "What is happening now is likely to reverse." The market is chopping/ranging. The Engine Widens sensitivity to filter out noise and stop runs.
2. The Elliott Wave Cycle (Crowd Psychology)
Price moves in 5-wave motive sequences followed by corrections.
• Waves 1 & 3: Institutional Accumulation/Mark-up.
• Waves 2 & 4: Profit Taking (The Pullback). These are the only safe entry points.
• Wave 5: Retail FOMO (The Trap). Identified by Momentum Divergence .
3. Smart Money Concepts (Liquidity)
Price moves from liquidity to liquidity.
• Order Blocks: Where institutions initiated the move.
• Breakers: Where institutions trapped traders (Support flips to Resistance).
• Fair Value Gaps: Where price moved too fast, leaving inefficiency.
PART 2: VISUAL INTELLIGENCE (COLOR THEORY)
The chart communicates instantly through a strict color-coded language.
🎨 THE RIBBON (Adaptive Equilibrium)
The background "Cloud" is an Adaptive EMA ribbon.
• Neon Green (#00FF88): Bullish Trend. Only look for Longs. Price is above the equilibrium mean.
• Neon Red (#FF3366): Bearish Trend. Only look for Shorts. Price is below the equilibrium mean.
• Grey/Narrow: Compression. The market is deciding. Do not trade inside a grey ribbon.
🎨 INSTITUTIONAL ZONES
• Green/Red Boxes (Order Blocks): Standard Support/Resistance. Valid entry zones, but lower probability.
• Vivid Purple Boxes (#9C27B0) - THE BREAKER: CRITICAL. This appears when a Green Order Block is smashed through by price. It turns Purple to signify it has flipped from Support to Resistance (or vice versa). A retest of a Purple Zone is the highest probability setup in the system.
• Dotted Outlines (FVG): Magnets. Do not place stops inside these; price will likely travel through them.
🎨 WAVE ANATOMY
• Cyan Lines: Valid Impulse Waves (1, 3, 5).
• Orange Lines/Dots: EXHAUSTION. If a wave line turns Orange, Angular Momentum is decaying. The trend is dying.
• Diamonds (◆): DIVERGENCE. Price made a Higher High, but the internal oscillator (MPI) made a Lower Low. Immediate reversal warning.
🎨 SIGNALS
• Triangles: Confirmed Entries. (Green = Long, Red = Short).
• Labels (e.g., A+): The Grade of the trade based on Confluence.
• A+: Perfect Confluence (Trend + Structure + Zone + Momentum).
• C: Counter-trend or Weak.
PART 3: THE DASHBOARD ECOSYSTEM
Three panels provide Total Situational Awareness. You must read them in order: Top Right → Bottom Left → Bottom Right.
1. MISSION CONTROL (Top Right)
This panel tells you the "Weather Report."
• Neural Status:
• 🧠 TREND: Safe to trade breakout and trend-following strategies.
• 🧠 CHOP: Danger. Use mean-reversion or stay out.
• 🧠 RND (Random): No clear edge.
• Phase: Displays the Bias (Bull/Bear) and Strength. "WEAK BEARISH" usually signals a bottom is forming.
• Score Bar: A live visual meter of the Confluence Score (0-100%).
2. THE ASSISTANT (Bottom Left)
This panel acts as your co-pilot, translating data into English.
• Situation:
• "💎 BULL GEM": You are in a range, at the bottom, showing exhaustion. Buy immediately.
• "🔥 COMPRESSION": Volatility squeeze. A violent move is imminent.
• Action: Tells you exactly what to do (e.g., "Wait for confluence," "Trail Stop," "Let it develop").
• Pro Metrics (Simulated):
• Win Rate: The percentage of signals on the current visible chart that hit Target 1.
• Profit Factor: Gross Win / Gross Loss. If this is < 1.0, stop trading this asset immediately.
• Buckets: Shows the win rate of A-Grade signals vs. C-Grade signals.
3. WAVE INTELLIGENCE (Bottom Right)
This panel provides structural context.
• Channel Gauge (0-100%):
• 0-20%: Oversold / Channel Bottom.
• 80-100%: Overbought / Channel Top.
• 50%: Equilibrium.
• W3/W1 Ratio: The "Health Check" of the trend.
• < 1.0: Weak. Wave 3 is shorter than Wave 1. The trend is struggling.
• > 1.618: Extended. The move is parabolic. Expect a snap-back.
• Trend Health (0-100): Composite score of sub-wave physics. If Health < 30, the trend is effectively dead.
PART 4: PARAMETER OPTIMIZATION (THE INPUTS)
Every input allows you to tune the engine. Here is the deep dive:
🧠 NEURAL ADAPTIVE ENGINE
• Enable Neural Adaptive Engine: Master switch for the Hurst calculation.
• Hurst Period (100):
• Adjustment: Increase to 200 for Crypto/Alts (too much noise). Decrease to 50 for
Forex/Indices (need speed).
• How to tell: If the dashboard says "TREND" but the chart is sideways, INCREASE this value.
• Min/Max Lookback: Defines the constraints. Only adjust if you are an advanced user creating a custom scalping setup (e.g., Min 3 / Max 10).
🌊 WAVE & STRUCTURE
• Base Swing Detection (8): The "Anchor."
• Scalpers (1m-5m): Set to 5-8.
• Swing Traders (1H-4H): Set to 15-20.
• Min Wave Size (ATR): Prevents the script from labeling tiny wicks as waves. Increase this during high-volatility news events.
🔗 MTF STRUCTURE MAPPING
• Require Macro Align: Strict Mode. If enabled, the script checks the Higher Timeframe (e.g., 4H). If 4H is Bearish, it BLOCKS all Long signals on the 5m chart. Use this to prevent counter-trend losses.
🏦 SMART MONEY CONCEPTS
• Enable Breakers: ALWAYS ON. This turns failed Order Blocks into Breaker Zones (Purple).
• Institutional Mode: ULTRA STRICT. If enabled, signals will ONLY fire if price is physically touching an Order Block, FVG, or Breaker. This creates very few, very high-quality signals.
🎯 SIGNAL ENGINE
• Signal Mode:
• Strict: Grades A+ and A only.
• Balanced: Grades B and above.
• Aggressive: Includes counter-trend scalps (Grade C).
• Min Confluence Score (5-35): The raw points needed to trigger. 5 is standard. 10 is conservative.
PART 5: TRADE EXECUTION PLAYBOOKS
PLAYBOOK A: THE "BREAKER RETEST" (Highest Probability)
1. Context: Ribbon is Green.
2. Event: Price creates a Red Order Block, then smashes upward through it.
3. Change: The Red Block turns Purple (Bullish Breaker).
4. Trigger: Price pulls back down to touch the top of the Purple Box.
5. Signal: Green Triangle appears.
6. Action: Max Size Entry. Stop Loss below the Purple Box. Target Wave 3 Projection.
PLAYBOOK B: THE "WAVE 4 DIP" (Trend Following)
1. Context: Wave count shows "3". Ribbon is Green.
2. Event: Price pulls back towards the Ribbon.
3. Wave Panel: Wave count flips to "4".
4. Trigger: Price touches Ribbon, prints Green Triangle.
5. Action: Standard Size Entry. Stop Loss at Swing Low. Target New High (Wave 5).
PLAYBOOK C: THE "HIDDEN GEM" (Range Reversal)
1. Context: Ribbon is Grey (Consolidation). Neural Status is CHOP.
2. Wave Panel: Channel Gauge is < 10% (Extreme Bottom).
3. Visuals: Orange Exhaustion Dot + Divergence Diamond (◆).
4. Assistant: Reads "💎 BULL GEM".
5. Action: Half Size Entry. This is a counter-trend trade. Target the middle of the range (50% Channel).
PLAYBOOK D: THE "BULL TRAP" (When to Fold)
1. Context: Wave Count is "5".
2. Wave Panel: Trend Health < 30. W3/W1 Ratio > 1.618 (Extended).
3. Visuals: Orange Line appears on price high.
4. Signal: Green Triangle appears (Grade C).
5. Action: NO TRADE. The system is warning you that even though a signal fired, the structural physics indicate exhaustion.
PART 6: GRADING & SCORING MATRIX
Every signal is graded on a 35-point scale. Know what you are buying.
• Trend Alignment (5 pts): Ribbon & HTF agreement.
• Structure (5 pts): BOS (Break of Structure) & Higher Highs.
• Physics (5 pts): MPI (Volume Flow) & Angular Velocity.
• Institutional Location (10 pts):
• Inside Order Block: +3 pts
• Inside Breaker: +4 pts
• Wave 2/4 Pullback: +3 pts
• Penalty: Wave 5 Extension (-3 pts).
Grade Scale:
• A+ (Score ≥ 70%): "All In" Setup.
• A (Score 55-69%): Strong Setup.
• B (Score 40-54%): Standard Setup.
• C (Score < 40%): Dangerous.
PART 7: RISK DISCLOSURE & LIMITATIONS
1. The Reality of Adaptation (Redrawing):
The Neural Engine is dynamic. As new data arrives, the calculation of "Chaos" changes. This means historical channel lines or wave labels may shift to fit the matured trend. HOWEVER: Entry Signals (Triangles) NEVER repaint once the bar is closed.
2. Simulation vs. Reality:
The Dashboard metrics (Win Rate, Profit Factor) are Simulations run on the historical data visible on your chart. They do not account for spread, slippage, or liquidity. They are a tool to gauge the current market personality, not a promise of future returns.
3. No Financial Advice:
Wave Dynamics is a tool for structural analysis. It helps you see the market, but it cannot trade for you. You are responsible for your own risk management.
CLOSING THOUGHTS
Wave Dynamics is not just an indicator; it is a lens. It allows you to see the market not as a random walk of candles, but as a structured, breathing entity.
Trust the Neural Status. Respect the Breakers. Fear the Exhaustion.
Taking you to school. — Dskyz, Trade with insight. Trade with anticipation.
Elliott Wave: Pro ForecastElliott Wave: Pro Forecast (Dual-Path Prediction)
The "Fork in the Road" for Price Action. Most indicators show you where price has been. This indicator predicts where price could go using standard Elliott Wave Fibonacci ratios and volatility analysis.
Unlike standard forecasters that force a single path, Pro Forecast acknowledges that the market is probabilistic. It visualizes the two most likely outcomes simultaneously:
Continuation: The current trend extends deeper (or higher).
Reversal: The trend exhausts and begins a new 5-wave motive structure.
How It Works
The script identifies the most recent "Live Pivot" (the unconfirmed high or low currently forming) and calculates volatility based on the previous swing. It then projects future price action using two distinct models:
The Extension Model: Projects a generic 0.5 volatility continuation.
The Wave Model: Projects a standard Elliott Wave 5-step sequence (or ABC correction) using classic Fibonacci ratios (0.382 retracements, 1.618 extensions).
Key Features
Dual-Path Visualization: See the Bearish breakdown and Bullish bounce scenarios at the same time.
"Dip Buy" Mode (Linked Scenarios): A unique feature that links the two paths. Instead of reversing now, it simulates a reversal starting after the extension. This is perfect for planning entries at lower support levels.
Smart Target Grid: Draws horizontal dotted lines at key price targets, making it easier to line up predictions with existing Support/Resistance zones.
Invalidation Level: Automatically marks the "Hard Stop" level (Start of Wave 1). If price crosses this red line, the bullish/bearish thesis is invalid.
Zero-Floor Logic: Smart math ensures projections never predict negative stock prices, even on high-volatility/low-cap assets.
Settings Guide
Sensitivity: Controls how fast pivots are detected.
Daily Chart: Recommend 3-4 for a 1-week outlook.
4H Chart: Recommend 8-12.
Show Continuation: Toggles the "Extension" line (Orange).
Show Reversal: Toggles the "Next Wave" sequence (Blue).
Start Reversal after Extension?:
Unchecked: Reversal starts from the current price (Current Bounce).
Checked: Reversal starts from the end of the Extension line (Future Bounce).
Risk Disclaimer
This tool is for educational purposes and visualization only. It projects geometric probabilities based on past volatility, not certainty. Always use proper risk management.
Fibonacci Sequence Grid [BigBeluga]🔵 OVERVIEW
A geometric price mapping tool that projects Fibonacci sequence levels and grid structures from recent price swings to help traders visualize natural expansion and reversion zones.
This indicator overlays Fibonacci-based structures directly on the chart, utilizing both grid projections and horizontal levels based on the classic Fibonacci integer sequence (0, 1, 1, 2, 3, 5, 8, ...). It identifies recent swing highs or lows and builds precision-aligned levels based on the trend direction.
🔵 CONCEPTS
Uses the Fibonacci integer sequence (not ratios) to define distances from the most recent swing point.
Identifies a trend based on EMA cross of fast and slow periods.
Projects two types of Fibonacci tools:
A grid projection from the swing point, displaying multiple sloped levels based on the sequence.
A set of horizontal Fibonacci levels for clean structural references.
Levels can be plotted from either swing low or high depending on the current trend direction.
Adjustable “Size” inputs control spacing between levels for better price alignment.
Lookback period defines how far the script searches for recent swing extremes.
🔵 FEATURES
Fibonacci Grid Projection:
Draws two mirrored Fibonacci grids—one expanding away from the swing high/low, the other converging toward price.
Swing-Based Trend Detection:
Uses a fast/slow EMA crossover to determine trend direction and reference swing points for projections.
Fibonacci Sequence Levels:
Displays horizontal levels based on the Fibonacci number sequence (0, 1, 2, 3, 5, 8, 13, 21...) for natural price targets.
Dynamic Labels and Coloring:
Each level is labeled with its sequence value and colored based on trend direction (e.g., red = downtrend, green = uptrend).
Both grids and levels can be toggled on/off independently.
Sizing controls allow tighter or looser clustering of levels depending on chart scale.
🔵 HOW TO USE
Enable Fibonacci Grid to visualize price expansion zones during impulsive trends.
Use Fibonacci Levels as horizontal support/resistance or target zones.
A label below price means the current trend is up and levels are projected from swing low.
A label above price means trend is down and levels are projected from swing high.
Adjust “Size” input to fit grid/level projection to your preferred chart scale or instrument volatility.
Use in confluence with price action, trend indicators, or volume tools for layered trading decisions.
🔵 CONCLUSION
Fibonacci Sequence Grid reimagines Fibonacci analysis using whole-number spacing from natural math progressions. Whether used for projecting grid-based expansions or horizontal support/resistance zones, it provides a powerful and intuitive structure to trade within. Perfect for traders who rely on symmetry, market geometry, and mathematically consistent levels.
TrendlinesTrendline S&R
This indicator is an automated technical analysis tool designed to identify the most relevant Support and Resistance (S&R) zones based on market pivots. Unlike standard pivot indicators that clutter the chart with historic lines, this script uses a "Closest-to-Price" algorithm to display only the single most relevant Support (Green) and Resistance (Red) zone currently interacting with price action.
It solves common frustrations with automated trendlines—specifically the issue of lines disappearing immediately upon a breakout—by introducing a Stability Buffer.
Key Features & Importance
The script scans hundreds of potential trendlines but only draws the one geographically closest to the current price.
Importance: This ensures you are looking at the zone that matters right now. It filters out distant or irrelevant historic lines, keeping your chart clean and focused on immediate price action.
🛡️ 5-Bar Stability Buffer (Anti-Flicker)
Feature: A hardcoded 5-bar "memory" prevents the zone from disappearing the moment price touches or breaks it.
Importance: This is critical for trading breakouts. It allows you to see the zone persist while price breaches it, helping you distinguish between a true breakout, a fakeout, or a retest, without the reference level vanishing from your screen.
🔍 Dynamic Pivot Filtering
Feature: Uses a restricted Pivot Strength (5-15) and Minimum Confirmation (2-8 touches).
Importance: By enforcing these limits, the indicator ignores insignificant market noise and micro-swings, ensuring that drawn zones represent structural market levels with genuine liquidity.
🔔 Integrated Alert System
Feature: Built-in alerts for "Zone Breakout" (candle close crossing the zone) and "Zone Touch" (wick entering the zone).
Importance: Allows you to set the indicator and walk away. You will be notified instantly when price interacts with these key levels, removing the need to stare at the chart.
📉 Adaptive Tolerance (Fixed ATR)
Feature: Uses a fixed ATR multiplier internally to determine the width of the zone.
Importance: This automatically adjusts the thickness of the support/resistance zone based on the asset's volatility.
Settings Guide
Bars to Apply: How far back in history the script looks for pivots (Default: 300).
Pivot Source: Choose between calculating from "High/Low" (wicks) or "Close" (bodies).
Pivot Strength: The number of bars required on each side to define a swing point (Range: 5–15).
Min Pivot Confirmation: The minimum number of touches required to validate a trendline (Range: 2–8).
How to Use
Add the indicator to your chart.
Adjust Pivot Strength if you want to catch smaller swings (lower number) or major structures (higher number).
Set an alert in TradingView by clicking the "Clock" icon, selecting this indicator, and choosing "Zone Breakout" or "Zone Touch".
Google Trends: ETH (Cryptollica)Google Trends: ETH (Cryptollica)
Google Trends data since 2016, Keyword: ETH
Smart Money Flow Cloud [BOSWaves]Smart Money Flow Cloud - Volume-Weighted Trend Detection with Adaptive Volatility Bands
Overview
Smart Money Flow Cloud is a volume flow-aware trend detection system that identifies directional market regimes through money flow analysis, constructing adaptive volatility bands that expand and contract based on institutional pressure intensity.
Instead of relying on traditional moving average crossovers or fixed-width channels, trend direction, band width, and signal generation are determined through volume-weighted money flow calculation, nonlinear flow strength modulation, and volatility-adaptive band construction.
This creates dynamic trend boundaries that reflect actual institutional buying and selling pressure rather than price momentum alone - tightening during periods of weak flow conviction, expanding during strong directional moves, and incorporating flow strength statistics to reveal whether regimes formed under accumulation or distribution conditions.
Price is therefore evaluated relative to adaptive bands anchored at a flow-informed baseline rather than conventional trend-following indicators.
Conceptual Framework
Smart Money Flow Cloud is founded on the principle that sustainable trends emerge where volume-weighted money flow confirms directional price movement rather than where price alone creates patterns.
Traditional trend indicators identify regime changes through price crossovers or slope analysis, which often ignore the underlying volume dynamics that validate or contradict those movements.This framework replaces price-centric logic with flow-driven regime detection informed by actual buying and selling volume.
Three core principles guide the design:
Trend direction should correspond to volume-weighted flow dominance, not price movement alone.
Band width must adapt dynamically to current flow strength and volatility conditions.
Flow intensity context reveals whether regimes formed under conviction or uncertainty.
This shifts trend analysis from static moving averages into adaptive, flow-anchored regime boundaries.
Theoretical Foundation
The indicator combines adaptive baseline smoothing, close location value (CLV) methodology, volume-weighted flow tracking, and nonlinear strength amplification.
A smoothed trend baseline (EMA or ALMA) establishes the core directional reference, while close location value measures where price settled within each bar's range. Volume weighting applies directional magnitude to flow calculation, which accumulates into a normalized money flow ratio. Flow strength undergoes nonlinear power transformation to amplify strong conviction periods and dampen weak flow environments. Average True Range (ATR) provides volatility-responsive band sizing, with final width determined by the interaction between base volatility and flow-modulated multipliers.
Four internal systems operate in tandem:
Adaptive Baseline Engine : Computes smoothed trend reference using either EMA or ALMA methodology with configurable secondary smoothing.
Money Flow Calculation System : Measures volume-weighted directional pressure through CLV analysis and ratio normalization.
Nonlinear Flow Strength Modulation : Applies power transformation to flow intensity, creating dynamic sensitivity scaling.
Volatility-Adaptive Band Construction : Scales band width using ATR measurement combined with flow-strength multipliers that range from minimum (calm) to maximum (strong flow) expansion.
This design allows bands to reflect actual institutional behavior rather than reacting mechanically to price volatility alone.
How It Works
Smart Money Flow Cloud evaluates price through a sequence of flow-aware processes:
Close Location Value (CLV) Calculation : Each bar's closing position within its high-low range is measured, creating a directional bias indicator ranging from -1 (closed at low) to +1 (closed at high).
Volume-Weighted Flow Tracking : CLV is multiplied by bar volume, then accumulated and normalized over a configurable flow window to produce a money flow ratio between -1 and +1.
Flow Smoothing and Strength Extraction : The raw money flow ratio undergoes optional smoothing, then nonlinear power transformation to amplify strong flow periods and compress weak flow environments.
Adaptive Baseline Construction : Price (both open and close) is smoothed using either EMA or ALMA methodology with optional secondary smoothing to create a stable trend reference.
Dynamic Band Sizing : ATR measurement is multiplied by a flow-strength-modulated factor that interpolates between minimum (tight) and maximum (wide) multipliers based on current flow conviction.
Regime Detection and Visualization : Price crossing above the upper band triggers bullish regime, crossing below the lower band triggers bearish regime. The baseline cloud visualizes open-close relationship within the current trend.
Retest Signal Generation : Price touching the baseline from within an established regime generates retest signals with configurable cooldown periods to prevent noise.
Together, these elements form a continuously updating trend framework anchored in volume flow reality.
Interpretation
Smart Money Flow Cloud should be interpreted as flow-confirmed trend boundaries:
Bullish Regime (Blue) : Activated when price crosses above the upper adaptive band, indicating volume-confirmed buying pressure exceeding volatility-adjusted resistance.
Bearish Regime (Red) : Established when price crosses below the lower adaptive band, identifying volume-confirmed selling pressure breaking volatility-adjusted support.
Baseline Cloud : The gap between smoothed open and smoothed close within the baseline visualizes intrabar directional bias - wider clouds indicate stronger intrabar momentum.
Adaptive Band Width : Reflects combined volatility and flow strength - wider bands during high-conviction institutional activity, tighter bands during consolidation or weak flow periods.
Buy/Sell Labels : Appear at regime switches when price crosses from one band to the other, marking potential trend inception points.
Retest Signals (✦) : Diamond markers indicate price touching the baseline within an established regime, often occurring during healthy pullbacks in trending markets.
Trend Strength Gauge : Visual meter displays current regime strength as a percentage, calculated from price position within the active band relative to baseline.
Background Gradient : Optional coloring intensity reflects flow strength magnitude, darkening during high-conviction periods.
Flow strength, band width adaptation, and baseline relationship outweigh isolated price fluctuations.
Signal Logic & Visual Cues
Smart Money Flow Cloud presents three primary interaction signals:
Regime Switch - Buy : Blue "Buy" label appears when price crosses above the upper band after previously being in a bearish regime, suggesting volume-confirmed bullish transition.
Regime Switch - Sell : Red "Sell" label displays when price crosses below the lower band after previously being in a bullish regime, indicating volume-confirmed bearish transition.
Trend Retest : Diamond (✦) markers appear when price touches the baseline within an established regime, with configurable cooldown periods to filter noise.
Alert generation covers regime switches and retest events for systematic monitoring.
Strategy Integration
Smart Money Flow Cloud fits within volume-informed and institutional flow trading approaches:
Flow-Confirmed Entry : Use regime switches as primary trend inception signals where volume validates directional breakouts.
Retest-Based Refinement : Enter on baseline retest signals within established regimes for improved risk-reward positioning during pullbacks.
Band Width Context : Expect wider price swings when bands expand (high flow strength), tighter ranges when bands contract (weak flow).
Baseline Cloud Confirmation : Favor trades where baseline cloud width confirms intrabar momentum alignment with regime direction.
Strength Gauge Filtering : Use trend strength percentage to gauge continuation probability - higher readings suggest stronger institutional conviction.
Multi-Timeframe Regime Alignment : Apply higher-timeframe regime context to filter lower-timeframe entries, taking only setups aligned with dominant flow direction.
Technical Implementation Details
Core Engine : Configurable EMA or ALMA baseline with secondary smoothing
Flow Model : Close Location Value (CLV) with volume weighting and ratio normalization
Strength Transformation : Configurable power function for nonlinear flow amplification
Band Construction : ATR-scaled width with flow-strength-interpolated multipliers
Visualization : Dual-line baseline cloud with gradient fills, regime-colored bands, and embedded strength gauge
Signal Logic : Band crossover detection with baseline retest identification and cooldown management
Performance Profile : Optimized for real-time execution with minimal computational overhead
Optimal Application Parameters
Timeframe Guidance:
1 - 5 min : Micro-structure regime detection for scalping and intraday reversals
15 - 60 min : Intraday trend identification with flow-validated swings
4H - Daily : Swing and position-level regime analysis with institutional flow context
Suggested Baseline Configuration:
Trend Length : 34
Trend Engine : EMA
Trend Smoothing : 3
Flow Window : 24
Flow Smoothing : 5
Flow Boost : 1.2
ATR Length : 14
Band Tightness (Calm) : 0.9
Band Expansion (Strong Flow) : 2.2
Reset Cooldown : 12
These suggested parameters should be used as a baseline; their effectiveness depends on the asset's volume profile, volatility characteristics, and preferred signal frequency, so fine-tuning is expected for optimal performance.
Parameter Calibration Notes
Use the following adjustments to refine behavior without altering the core logic:
Bands too wide/frequent whipsaws : Reduce "Band Expansion (Strong Flow)" to limit maximum band width, or increase "Band Tightness (Calm)" to widen minimum bands and reduce noise sensitivity.
Trend baseline too choppy : Increase "Trend Length" for smoother baseline, or increase "Trend Smoothing" for additional filtering.
Flow readings unstable : Increase "Flow Smoothing" to reduce bar-to-bar noise in money flow calculation.
Missing legitimate regime changes : Decrease "Trend Length" for faster baseline response, or reduce "Band Tightness (Calm)" for earlier breakout detection.
Too many retest signals : Increase "Reset Cooldown" to space out retest markers, or disable retest signals entirely if not using pullback entries.
Flow strength not responding : Increase "Flow Boost" (power factor) to amplify strong flow differentiation, or decrease "Flow Window" to emphasize recent volume activity.
Prefer different smoothing characteristics : Switch "Trend Engine" to ALMA and adjust "ALMA Offset" (higher = more recent weighting) and "ALMA Sigma" (higher = smoother) for alternative baseline behavior.
Adjustments should be incremental and evaluated across multiple session types rather than isolated market conditions.
Performance Characteristics
High Effectiveness:
Markets with consistent volume participation and institutional flow
Instruments where volume accurately reflects true liquidity and conviction
Trending environments where flow confirms directional price movement
Mean-reversion strategies using retest signals within established regimes
Reduced Effectiveness:
Extremely low volume environments where flow calculations become unreliable
News-driven or gapped markets with discontinuous volume patterns
Highly manipulated or thinly traded instruments with erratic volume distribution
Ranging markets where price oscillates within bands without conviction
Integration Guidelines
Confluence : Combine with BOSWaves structure, order flow analysis, or traditional volume profile
Flow Validation : Trust regime switches accompanied by strong flow readings and wide band expansion
Context Awareness : Consider whether current market regime matches historical flow patterns
Retest Discipline : Use baseline retest signals as confirmation within trends, not standalone entries
Breach Management : Exit regime-aligned positions when price crosses opposing band with volume confirmation
Disclaimer
Smart Money Flow Cloud is a professional-grade volume flow and trend analysis tool. Results depend on market conditions, volume reliability, parameter selection, and disciplined execution. BOSWaves recommends deploying this indicator within a broader analytical framework that incorporates price structure, market context, and comprehensive risk management.
Multi-Filter Profit MaximizerDescription : This script is a trend-following system designed to maximize profits by capturing extended trends while filtering out market noise. It integrates four core components:
SuperTrend (Customized): Acts as a dynamic trailing stop and trend baseline.
ADX Filter: Ensures signals only occur during active volatility to avoid choppy markets.
CVD (Cumulative Volume Delta): Validates the price movement with actual volume flow.
Stochastic Momentum: Pinpoints high-probability entry entries within the trend.
--------------------------------------------------------------------------------------------------------------
How to Use This Indicator (Profit Maximization Manual)
This indicator is designed to prioritize **“win rate” and “price range”** over the number of entries.
Market Environment Recognition (Background & Lines):
Green background & green line: An uptrend. Focus solely on long positions.
Red background & red line: A downtrend. Focus solely on short positions.
EMA 200 (Orange Line): The iron rule is to go long if the candlestick is above this line, and short if it's below.
Entry (BUY / SELL Signals):
Enter when the BUY or SELL label appears.
This is the moment when the “trend direction,” “momentum via ADX,” “fund flow via CVD,” and “timing via Stochastic” all align perfectly.
Profit Maximization Exit (Most Critical):
Stop Loss (SL): Exit immediately if the candle body breaks below the green (or red) SuperTrend line right after entry. No hesitation.
Take Profit (TP):
Method A (Trend Riding): Hold until the SuperTrend line changes color. If a major trend emerges, this can yield tremendous profits.
Method B (Conservative Approach): Take half the profit at roughly a 1:2 risk-reward ratio, then hold the remainder aligned with the SuperTrend.
Why This is “The Best”
Many indicators get whipped back and forth in range-bound markets, spitting out profits. It's coded to generate absolutely no signals when ADX < 20 (weak market). Furthermore, using SuperTrend as the stop-loss line forces a structure that comes closest to the Holy Grail of trading: **“Small losses, unlimited profits as long as the trend continues.”**
Weighted Stochastic Oscillator [SeerQuant]Weighted Stochastic Oscillator (WSTO)
The Weighted Stochastic Oscillator (WSTO) is an enhanced stochastic-based trend oscillator that builds on the traditional %K/%D framework by introducing adaptive weighting and configurable smoothing. By dynamically amplifying the oscillator’s deviation from the 50 midline based on a selected market “weight” (Volume, Momentum, Volatility, or Reversion Factor), WSTO provides a cleaner view of trend strength and regime shifts—without relying on classic 80/20 overbought/oversold bands.
⚙️ How It Works
WSTO uses a standard stochastic calculation, measuring where price sits within its rolling high/low range over a lookback period. That %K is then “context-weighted” using your selected weighting method: Volume, Momentum, Volatility, or Reversion Factor.
The weighting is normalized for stability (so it doesn’t blow out during abnormal periods), then applied by amplifying the oscillator’s deviation from the 50 midline. In practice, this means strong conditions make the oscillator lean harder away from 50 (clearer trend), while quieter conditions keep it closer to traditional stochastic behaviour.
The weighted %K is then smoothed using your chosen moving average type, and a second smoothing pass generates the %D signal line. Trend logic is based on a neutral band around 50: bullish when the oscillator holds above (50 + Neutral Zone), bearish when it holds below (50 - Neutral Zone), and neutral while it remains inside that range.
✨ Customizable Settings
WSTO is built to be tuned without overcomplication. You can choose the stochastic source mode (Close, HLC3, OHLC4, or a custom input source), set the stochastic length, and control smoothing via separate %K and %D smoothing lengths.
You can also pick from a wide selection of moving average types (SMA, EMA, RMA, HMA, DEMA, TEMA, etc.) to match your style.
The weighting method is the core differentiator. Volume weighting emphasizes participation, Momentum weighting emphasizes directional impulse, Volatility weighting emphasizes expansion/contraction, and Reversion Factor weighting biases toward mean-reversion dynamics by responding inversely to variance. On the style side, you can select a preset colour scheme (Default/Modern/Cool/Monochrome) or enable custom bull/bear/neutral colours. Candle coloring is optional, and you can decide whether candles follow %K or %D.
🚀 Features and Benefits
WSTO gives you an alternative stochastic that adapts to market conditions instead of treating every regime the same. The weighting engine makes trend strength more obvious when conditions justify it, while the neutral-zone framework reduces noise compared to classic OB/OS bands. With flexible smoothing and clean visual state changes, it works well as a trend filter, a confirmation layer, or a regime signal alongside other systems.
📜 Disclaimer
This indicator is for educational purposes only and does not constitute financial advice. Past performance does not guarantee future results. Always consult a licensed financial advisor before making trading decisions. Use at your own risk.
Support & Resistance with MA Ribbons LITE Support & Resistance with MA Ribbon LITE
Overview
Support & Resistance with MA Ribbon LITE is a technical analysis indicator for TradingView that combines a flexible Moving Average (MA) Ribbon with a dynamic Support & Resistance (S/R) system.
The indicator is designed as a visual decision-support tool, allowing traders to evaluate trend structure, momentum context, and key price reaction zones within a single, uncluttered chart overlay.
This script is published as open source under the Mozilla Public License 2.0 , encouraging transparency, learning, and community-driven development.
Core Components
1. Moving Average Ribbon System
The MA Ribbon consists of two configurable moving averages (Fast and Slow) with multiple calculation and smoothing options, including:
EMA, SMA, WMA, VWMA
DEMA, TEMA, Zero-Lag EMA
Hull MA, Linear Regression MA
Super Smoother, Smoothed MA, Laguerre MA
Key features include:
Trend-aware ribbon fill (bullish / bearish)
Optional candle coloring aligned with ribbon state
Minute-based anchor timeframe logic for consistent trend structure
Optional MA cross, swing, and continuation markers
Alert support for MA-related events
The MA Ribbon is intended to provide trend context , not standalone trade signals.
2. Support & Resistance Engine
The Support & Resistance system is based on pivot structure analysis and dynamically adapts to new price data.
Features include:
Main and strong support/resistance levels
Up to 12 active levels displayed on the chart
Preset sensitivities (Scalp, Intraday, Swing) and custom configuration
Optional multi-timeframe (MTF) level detection
Adaptive labels with automatic contrast handling
Optional strength filtering based on historical interactions
Optional heat map visualization reflecting level interaction frequency
All levels are plotted directly on the price chart for immediate contextual reference.
Alert System
The script includes a configurable alert framework covering:
Main and strong level touches
Breakouts and breakdowns
Retests of broken levels
Optional rejection detection (wick beyond a level with close back inside)
Cooldown logic to limit repeated alerts in consolidation phases
Alerts are informational only and should always be confirmed visually.
Customization & Performance
Unified color presets (Classic, Aqua, Cosmic, Ember, Neon, Custom)
Independent opacity control for MA Ribbon and candles
Modular on/off controls for MA Ribbon and S/R components
Optimized plotting to remain within TradingView limits
Designed for stable performance across lower and higher timeframes
Intended Use
This indicator is designed to assist with chart interpretation and market structure analysis. It may help users:
Identify prevailing trend conditions
Observe price behavior around structurally relevant levels
Combine trend context with horizontal market structure
Reduce chart clutter by consolidating multiple concepts into one script
This indicator is not a trading strategy, does not provide financial advice, and should be used alongside independent analysis and appropriate risk management.
How to Use
1. Chart Setup
Add the indicator to any chart and timeframe.
Both the MA Ribbon and Support & Resistance systems are enabled by default and can be managed independently via the Master Controls section.
General guidance:
Higher timeframes for structural context
Lower timeframes for execution and refinement
Applicable across different markets and instruments
2. Using the MA Ribbon
The MA Ribbon visualizes trend direction and momentum context.
General interpretation:
Price above both MAs → bullish bias
Price below both MAs → bearish bias
Ribbon color reflects trend alignment
Ribbon compression may indicate consolidation or transition
Optional features include candle coloring, MA cross markers, and filtered continuation arrows.
Best practice:
Use the MA Ribbon to identify the market regime before reacting to support or resistance levels.
MA Ribbon – Minute-Based Timeframe Logic
Anchor Timeframe (Minutes)
Anchors MA calculations to a fixed timeframe expressed in minutes.
Examples:
60 = 1 hour
240 = 4 hours
0 = use current chart timeframe
How It Works
The anchor automatically scales MA lengths so that the same trend structure is preserved across different chart timeframes.
Example (Anchor = 60):
5-minute chart → follows 1-hour structure
15-minute chart → follows the same 1-hour structure
1-hour chart → standard calculation
Show Ribbon Only If Chart TF > Anchor
Optionally hides the MA Ribbon on chart timeframes lower than the anchor to reduce visual noise.
3. Using Support & Resistance Levels
Support and resistance levels are derived from pivot structures and update dynamically.
Level types:
Main Support / Resistance (most recent and relevant)
Strong Support / Resistance (confirmed pivots)
Additional historical levels (up to 12 total)
Usage guidelines:
Focus on price behavior around levels rather than exact prices
Combine level reactions with MA Ribbon trend context
Use strength filtering to reduce weaker levels
Heat map mode highlights frequently interacted zones
4. Combining Trend and Structure
The indicator is most effective when both systems are used together:
In uptrends, focus on reactions near support
In downtrends, focus on reactions near resistance
Breakouts are more relevant when aligned with trend context
Retests gain importance when structure and trend agree
Customization Tips
Use preset sensitivities (Scalp / Intraday / Swing) for quick setup
Enable MTF S/R to reference higher-timeframe structure
Adjust label size, offset, and precision for readability
Disable unused components to improve performance on lower-end systems
This combined view helps improve contextual clarity and reduce noise.
5. Alerts Usage
Alerts are optional and fully configurable.
Cooldown settings can be used to limit repeated notifications during ranging conditions.
All alerts are informational and should be visually validated.
Open Source & Credits
This script is released as open source under the Mozilla Public License 2.0.
Parts of the MA Ribbon logic and conceptual inspiration are derived from publicly shared work by JustUncleL on TradingView.
Respect and thanks are extended for these contributions.
You are free to:
Study the code
Modify it for personal use
Share improvements under the same license terms
Disclaimer
This indicator is provided for educational and informational purposes only.
No guarantees are made regarding accuracy, performance, or outcomes.
Use at your own discretion.
Previous Hourly candle2 previous hourly high and low candle and last H4 high and low candle for intra or scalp strategy
Supply & Demand Sniper369Indicator Philosophy: The Convergence of Structure and Liquidity
The Supply & Demand Sniper369 is not just another signal generator; it is a professional-grade execution framework built on the principles of Institutional Order Flow and Liquidity Engineering. While standard indicators often lag or provide signals in "no-man's land," this script is designed to identify high-probability reversal points by combining macro-structural zones with micro-execution triggers.
What Makes This Script Original?
Most scripts treat Supply/Demand and Entry Triggers as separate entities. The originality of the Sniper369 lies in its Strict Hierarchical Logic. It employs a "Two-Factor Authentication" system for trades:
1. Structural Validation: Identifying where "Smart Money" has historically left unfilled orders.
2. Liquidity Sweep Confirmation: Using the Enigma 369 logic to detect a specific manipulation pattern (a stop-run or "sweep") that occurs exclusively within those structural zones.
By using Pine Script v6 Object-Oriented Programming, the script manages dynamic arrays of boxes and lines that auto-delete upon mitigation, ensuring your chart remains a clean, actionable workspace.
Underlying Concepts & Calculations
1. Macro: Structural Supply & Demand
The indicator calculates zones based on Pivot Strength and Volatility Scaling.
Calculations: It scans for major structural pivots ( and ). Once a pivot is confirmed, it doesn't just draw a line; it calculates a zone width based on the Average True Range (ATR).
Why it works: Institutions do not enter at a single price; they enter in "pockets" of liquidity. Using ATR-based zones ensures that on high-volatility pairs (like Gold or GBP/JPY), your zones are appropriately wide, while on lower-volatility pairs, they remain tight and precise.
2. Micro: The Enigma 369 Sniper Logic
Once price enters a zone, the "Sniper" logic activates. This is based on the Institutional Wick-Liquidity concept.
The Sweep: The script looks for a candle that breaks the high/low of the previous candle (trapping "breakout" traders) but fails to hold that level.
The Mean Threshold (50% Wick): A core calculation of the Enigma logic is the midpoint of the rejection wick.
Calculation: for Sells.
Logic: Institutions often re-test the 50% level of a long wick to fill the remaining orders before the real move starts.
How to Use the Indicator
Step 1: Wait for Structural Alignment
Observe the Teal (Demand) and Red (Supply) boxes. These are your "Points of Interest" (POI). Do not take any trades until the price is physically touching or inside these boxes.
Step 2: Monitor for the Sniper Trigger
When the price is inside a zone, look for the appearance of the Solid and Dotted lines.
The Solid Line: This is the extreme of the manipulation candle. It serves as your structural invalidation level (Stop Loss).
The Dotted Line: This is the 50% Wick level. It is your "Sniper Entry" target.
Step 3: Execution & Alerts
The script features a built-in alert system that notifies you the moment a Sniper activation occurs inside a zone.
Conservative Entry: Place a Limit Order at the Dotted Line.
Aggressive Entry: Market enter on the close of the Sniper candle if the price has already reacted strongly.
Exit: Target the opposing Supply or Demand zone for a high Risk-to-Reward ratio.
Technical Summary for Traders
Trend Detection: Uses an EMA-50 Filter to ensure Snipers only fire in the direction of the dominant trend (optional).
Scalping/Day Trading: Optimized for the 1m, 5m, and 15m timeframes, but functions perfectly on 4H/Daily for swing traders.
Dynamic Cleanup: The script automatically deletes lines if the price closes past them, signaling that the "Liquidity Grab" was actually a breakout, thus preventing you from entering a losing trade.
eBacktesting - Learning: RSI DivergenceseBacktesting - Learning: RSI Divergences is meant to train your eye to spot when a trend is losing momentum before price fully turns.
How to study it (step-by-step)
1. Start with the trend
- First decide if price is generally trending up or down (higher highs / higher lows vs lower highs / lower lows).
- Divergences matter most after a trend has been running for a while.
2. Look for the “mismatch”
- Bearish divergence: price prints higher highs, but RSI prints lower highs.
- This often shows up near the end of a strong bullish run, when buyers are still pushing price up but with less momentum.
- Bullish divergence: price prints lower lows, but RSI prints higher lows.
- This can show up near the end of a bearish move, when selling pressure is fading.
3. Treat divergence as a warning, not an entry
- The key lesson: divergence often signals trend weakness, not an instant reversal.
- After a divergence appears, study what happens next: stalling, ranging, a pullback, or a full reversal.
4. Add simple confirmation
- Practice waiting for something obvious after the divergence:
a break of a small support/resistance level,
a shift in swing structure,
or a clear rejection candle from a key area.
- This helps you avoid taking every divergence as a trade signal.
5. Use it inside eBacktesting (best practice)
- Replay the chart and pause on each divergence mark.
- Log:
Where it happened (after a long run or in the middle of chop?),
Whether price stalled first or reversed immediately,
What confirmation appeared (if any),
The best “invalidation” idea (what would prove you wrong?).
- Over time you’ll see which divergences are meaningful for your market and session, and which ones are noise.
These indicators are built to pair perfectly with the eBacktesting extension, where traders can practice these concepts step-by-step. Backtesting concepts visually like this is one of the fastest ways to learn, build confidence, and improve trading performance.
Educational use only. Not financial advice.
SMC Flow: Order Blocks & FVGDescription:
This indicator is designed to identify key liquidity zones based on Smart Money Concepts (SMC). It focuses on identifying high-probability reversal and continuation areas by tracking Order Blocks and Price Imbalances.
Key Features:
Order Blocks (OB): Automatically identifies supply and demand zones. The script filters for candles with high relative volume (above 20-period SMA) to ensure the zone represents significant market activity.
Fair Value Gaps (FVG): Detects 3-candle imbalance structures where price moved rapidly, leaving "gaps" that often act as magnets for future price action.
Structure Tracking: Includes a visual step-line based on the highest high and lowest low of the last 10 bars to help traders identify the current market bias.
How to use:
Demand/Supply Zones: Look for Price Action confirmation when the market returns to the highlighted Order Block boxes.
Efficiency: Use FVG boxes to identify where the market is "unbalanced." These areas often get filled before a trend continues.
Confluence: This tool is most effective when used in alignment with higher timeframe analysis and additional technical filters.
Synthetic Renko Overlay + Instant Expansion Alert✔ Builds Renko bricks internally
✔ Overlays them on ANY chart (3m recommended)
✔ Detects sudden aggressive brick growth
✔ Fires alert on the FIRST push
✔ Works for NQ / ES / BTC / any market
Sessions & Key Levels {basic}Introduction
Sessions & Key Levels {basic} is a streamlined key level indicator designed to provide traders with clear visual structure around intraday trading sessions and essential higher timeframe reference levels.
The {basic} version focuses on the most commonly used session and price levels, helping traders identify important areas of interest without overwhelming the chart. It is ideal for traders who want a clean, reliable framework for session-based and timeframe-based analysis.
Description
The indicator plots the Asia, London and New York trading sessions directly on the chart, including session boxes and key session levels. Session highs and lows update dynamically while the session is active, providing real-time context as price develops.
In addition to session levels, the indicator includes current and previous period levels from a single configurable timeframe. These levels highlight important open, high, low and midpoint references that are frequently respected by price and commonly used for intraday bias, structure and trade planning.
The {basic} version is designed to remain visually minimal, with fixed styling and simplified settings, making it easy to use straight out of the box.
Features
Global session windows
Asia, London and New York sessions.
Custom session times.
Session boxes with adaptive highs and lows.
Session levels
Open, high, low and midpoint per session.
Automatically updates during active sessions.
Clean, consistent labelling.
Previous period levels
One configurable timeframe.
Open, high, low and midpoint of the prior period.
Useful for daily or intraday reference levels.
Current period levels
Tracks live open, high, low and midpoint of the selected timeframe.
Updates dynamically as the timeframe progresses.
Simplified design
Fixed line styles and colors for clarity.
Dark and light theme support.
Minimal settings for ease of use.
Terms & Conditions
This indicator is provided for educational and informational purposes only and does not constitute financial advice.
Trading involves risk and past performance is not indicative of future results.
The user assumes full responsibility for any trading decisions made using this indicator.
BUZARA// © Buzzara
// =================================
// PLEASE SUPPORT THE TEAM
// =================================
//
// Telegram: t.me
// =================================
//@version=5
VERSION = ' Buzzara2.0'
strategy('ALGOX V6_1_24', shorttitle = '🚀〄 Buzzara2.0 〄🚀'+ VERSION, overlay = true, explicit_plot_zorder = true, pyramiding = 0, default_qty_type = strategy.percent_of_equity, initial_capital = 1000, default_qty_value = 1, calc_on_every_tick = false, process_orders_on_close = true)
G_SCRIPT01 = '■ ' + 'SAIYAN OCC'
//#region ———— <↓↓↓ G_SCRIPT01 ↓↓↓> {
// === INPUTS ===
res = input.timeframe('15', 'TIMEFRAME', group ="NON REPAINT")
useRes = input(true, 'Use Alternate Signals')
intRes = input(10, 'Multiplier for Alernate Signals')
basisType = input.string('ALMA', 'MA Type: ', options= )
basisLen = input.int(50, 'MA Period', minval=1)
offsetSigma = input.int(5, 'Offset for LSMA / Sigma for ALMA', minval=0)
offsetALMA = input.float(2, 'Offset for ALMA', minval=0, step=0.01)
scolor = input(false, 'Show coloured Bars to indicate Trend?')
delayOffset = input.int(0, 'Delay Open/Close MA', minval=0, step=1,
tooltip = 'Forces Non-Repainting')
tradeType = input.string('BOTH', 'What trades should be taken : ',
options = )
//=== /INPUTS ===
h = input(false, 'Signals for Heikin Ashi Candles')
//INDICATOR SETTINGS
swing_length = input.int(10, 'Swing High/Low Length', group = 'Settings', minval = 1, maxval = 50)
history_of_demand_to_keep = input.int(20, 'History To Keep', minval = 5, maxval = 50)
box_width = input.float(2.5, 'Supply/Demand Box Width', group = 'Settings', minval = 1, maxval = 10, step = 0.5)
//INDICATOR VISUAL SETTINGS
show_zigzag = input.bool(false, 'Show Zig Zag', group = 'Visual Settings', inline = '1')
show_price_action_labels = input.bool(false, 'Show Price Action Labels', group = 'Visual Settings', inline = '2')
supply_color = input.color(#00000000, 'Supply', group = 'Visual Settings', inline = '3')
supply_outline_color = input.color(#00000000, 'Outline', group = 'Visual Settings', inline = '3')
demand_color = input.color(#00000000, 'Demand', group = 'Visual Settings', inline = '4')
demand_outline_color = input.color(#00000000, 'Outline', group = 'Visual Settings', inline = '4')
bos_label_color = input.color(#00000000, 'BOS Label', group = 'Visual Settings', inline = '5')
poi_label_color = input.color(#00000000, 'POI Label', group = 'Visual Settings', inline = '7')
poi_border_color = input.color(#00000000, 'POI border', group = 'Visual Settings', inline = '7')
swing_type_color = input.color(#00000000, 'Price Action Label', group = 'Visual Settings', inline = '8')
zigzag_color = input.color(#00000000, 'Zig Zag', group = 'Visual Settings', inline = '9')
//END SETTINGS
// FUNCTION TO ADD NEW AND REMOVE LAST IN ARRAY
f_array_add_pop(array, new_value_to_add) =>
array.unshift(array, new_value_to_add)
array.pop(array)
// FUNCTION SWING H & L LABELS
f_sh_sl_labels(array, swing_type) =>
var string label_text = na
if swing_type == 1
if array.get(array, 0) >= array.get(array, 1)
label_text := 'HH'
else
label_text := 'LH'
label.new(
bar_index - swing_length,
array.get(array,0),
text = label_text,
style = label.style_label_down,
textcolor = swing_type_color,
color = swing_type_color,
size = size.tiny)
else if swing_type == -1
if array.get(array, 0) >= array.get(array, 1)
label_text := 'HL'
else
label_text := 'LL'
label.new(
bar_index - swing_length,
array.get(array,0),
text = label_text,
style = label.style_label_up,
textcolor = swing_type_color,
color = swing_type_color,
size = size.tiny)
// FUNCTION MAKE SURE SUPPLY ISNT OVERLAPPING
f_check_overlapping(new_poi, box_array, atrValue) =>
atr_threshold = atrValue * 2
okay_to_draw = true
for i = 0 to array.size(box_array) - 1
top = box.get_top(array.get(box_array, i))
bottom = box.get_bottom(array.get(box_array, i))
poi = (top + bottom) / 2
upper_boundary = poi + atr_threshold
lower_boundary = poi - atr_threshold
if new_poi >= lower_boundary and new_poi <= upper_boundary
okay_to_draw := false
break
else
okay_to_draw := true
okay_to_draw
// FUNCTION TO DRAW SUPPLY OR DEMAND ZONE
f_supply_demand(value_array, bn_array, box_array, label_array, box_type, atrValue) =>
atr_buffer = atrValue * (box_width / 10)
box_left = array.get(bn_array, 0)
box_right = bar_index
var float box_top = 0.00
var float box_bottom = 0.00
var float poi = 0.00
if box_type == 1
box_top := array.get(value_array, 0)
box_bottom := box_top - atr_buffer
poi := (box_top + box_bottom) / 2
else if box_type == -1
box_bottom := array.get(value_array, 0)
box_top := box_bottom + atr_buffer
poi := (box_top + box_bottom) / 2
okay_to_draw = f_check_overlapping(poi, box_array, atrValue)
// okay_to_draw = true
//delete oldest box, and then create a new box and add it to the array
if box_type == 1 and okay_to_draw
box.delete( array.get(box_array, array.size(box_array) - 1) )
f_array_add_pop(box_array, box.new( left = box_left, top = box_top, right = box_right, bottom = box_bottom, border_color = supply_outline_color,
bgcolor = supply_color, extend = extend.right, text = 'SUPPLY', text_halign = text.align_center, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))
box.delete( array.get(label_array, array.size(label_array) - 1) )
f_array_add_pop(label_array, box.new( left = box_left, top = poi, right = box_right, bottom = poi, border_color = poi_border_color,
bgcolor = poi_border_color, extend = extend.right, text = 'POI', text_halign = text.align_left, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))
else if box_type == -1 and okay_to_draw
box.delete( array.get(box_array, array.size(box_array) - 1) )
f_array_add_pop(box_array, box.new( left = box_left, top = box_top, right = box_right, bottom = box_bottom, border_color = demand_outline_color,
bgcolor = demand_color, extend = extend.right, text = 'DEMAND', text_halign = text.align_center, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))
box.delete( array.get(label_array, array.size(label_array) - 1) )
f_array_add_pop(label_array, box.new( left = box_left, top = poi, right = box_right, bottom = poi, border_color = poi_border_color,
bgcolor = poi_border_color, extend = extend.right, text = 'POI', text_halign = text.align_left, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))
// FUNCTION TO CHANGE SUPPLY/DEMAND TO A BOS IF BROKEN
f_sd_to_bos(box_array, bos_array, label_array, zone_type) =>
if zone_type == 1
for i = 0 to array.size(box_array) - 1
level_to_break = box.get_top(array.get(box_array,i))
// if ta.crossover(close, level_to_break)
if close >= level_to_break
copied_box = box.copy(array.get(box_array,i))
f_array_add_pop(bos_array, copied_box)
mid = (box.get_top(array.get(box_array,i)) + box.get_bottom(array.get(box_array,i))) / 2
box.set_top(array.get(bos_array,0), mid)
box.set_bottom(array.get(bos_array,0), mid)
box.set_extend( array.get(bos_array,0), extend.none)
box.set_right( array.get(bos_array,0), bar_index)
box.set_text( array.get(bos_array,0), 'BOS' )
box.set_text_color( array.get(bos_array,0), bos_label_color)
box.set_text_size( array.get(bos_array,0), size.small)
box.set_text_halign( array.get(bos_array,0), text.align_center)
box.set_text_valign( array.get(bos_array,0), text.align_center)
box.delete(array.get(box_array, i))
box.delete(array.get(label_array, i))
if zone_type == -1
for i = 0 to array.size(box_array) - 1
level_to_break = box.get_bottom(array.get(box_array,i))
// if ta.crossunder(close, level_to_break)
if close <= level_to_break
copied_box = box.copy(array.get(box_array,i))
f_array_add_pop(bos_array, copied_box)
mid = (box.get_top(array.get(box_array,i)) + box.get_bottom(array.get(box_array,i))) / 2
box.set_top(array.get(bos_array,0), mid)
box.set_bottom(array.get(bos_array,0), mid)
box.set_extend( array.get(bos_array,0), extend.none)
box.set_right( array.get(bos_array,0), bar_index)
box.set_text( array.get(bos_array,0), 'BOS' )
box.set_text_color( array.get(bos_array,0), bos_label_color)
box.set_text_size( array.get(bos_array,0), size.small)
box.set_text_halign( array.get(bos_array,0), text.align_center)
box.set_text_valign( array.get(bos_array,0), text.align_center)
box.delete(array.get(box_array, i))
box.delete(array.get(label_array, i))
// FUNCTION MANAGE CURRENT BOXES BY CHANGING ENDPOINT
f_extend_box_endpoint(box_array) =>
for i = 0 to array.size(box_array) - 1
box.set_right(array.get(box_array, i), bar_index + 100)
//
stratRes = timeframe.ismonthly ? str.tostring(timeframe.multiplier * intRes, '###M') :
timeframe.isweekly ? str.tostring(timeframe.multiplier * intRes, '###W') :
timeframe.isdaily ? str.tostring(timeframe.multiplier * intRes, '###D') :
timeframe.isintraday ? str.tostring(timeframe.multiplier * intRes, '####') :
'60'
src = h ? request.security(ticker.heikinashi(syminfo.tickerid),
timeframe.period, close, lookahead = barmerge.lookahead_off) : close
// CALCULATE ATR
atrValue = ta.atr(50)
// CALCULATE SWING HIGHS & SWING LOWS
swing_high = ta.pivothigh(high, swing_length, swing_length)
swing_low = ta.pivotlow(low, swing_length, swing_length)
// ARRAYS FOR SWING H/L & BN
var swing_high_values = array.new_float(5,0.00)
var swing_low_values = array.new_float(5,0.00)
var swing_high_bns = array.new_int(5,0)
var swing_low_bns = array.new_int(5,0)
// ARRAYS FOR SUPPLY / DEMAND
var current_supply_box = array.new_box(history_of_demand_to_keep, na)
var current_demand_box = array.new_box(history_of_demand_to_keep, na)
// ARRAYS FOR SUPPLY / DEMAND POI LABELS
var current_supply_poi = array.new_box(history_of_demand_to_keep, na)
var current_demand_poi = array.new_box(history_of_demand_to_keep, na)
// ARRAYS FOR BOS
var supply_bos = array.new_box(5, na)
var demand_bos = array.new_box(5, na)
//END CALCULATIONS
// NEW SWING HIGH
if not na(swing_high)
//MANAGE SWING HIGH VALUES
f_array_add_pop(swing_high_values, swing_high)
f_array_add_pop(swing_high_bns, bar_index )
if show_price_action_labels
f_sh_sl_labels(swing_high_values, 1)
f_supply_demand(swing_high_values, swing_high_bns, current_supply_box, current_supply_poi, 1, atrValue)
// NEW SWING LOW
else if not na(swing_low)
//MANAGE SWING LOW VALUES
f_array_add_pop(swing_low_values, swing_low)
f_array_add_pop(swing_low_bns, bar_index )
if show_price_action_labels
f_sh_sl_labels(swing_low_values, -1)
f_supply_demand(swing_low_values, swing_low_bns, current_demand_box, current_demand_poi, -1, atrValue)
f_sd_to_bos(current_supply_box, supply_bos, current_supply_poi, 1)
f_sd_to_bos(current_demand_box, demand_bos, current_demand_poi, -1)
f_extend_box_endpoint(current_supply_box)
f_extend_box_endpoint(current_demand_box)
channelBal = input.bool(false, "Channel Balance", group = "CHART")
lr_slope(_src, _len) =>
x = 0.0, y = 0.0, x2 = 0.0, xy = 0.0
for i = 0 to _len - 1
val = _src
per = i + 1
x += per
y += val
x2 += per * per
xy += val * per
_slp = (_len * xy - x * y) / (_len * x2 - x * x)
_avg = y / _len
_int = _avg - _slp * x / _len + _slp
lr_dev(_src, _len, _slp, _avg, _int) =>
upDev = 0.0, dnDev = 0.0
val = _int
for j = 0 to _len - 1
price = high - val
if price > upDev
upDev := price
price := val - low
if price > dnDev
dnDev := price
price := _src
val += _slp
//
= ta.kc(close, 80, 10.5)
= ta.kc(close, 80, 9.5)
= ta.kc(close, 80, 8)
= ta.kc(close, 80, 3)
barsL = 10
barsR = 10
pivotHigh = fixnan(ta.pivothigh(barsL, barsR) )
pivotLow = fixnan(ta.pivotlow(barsL, barsR) )
source = close, period = 150
= lr_slope(source, period)
= lr_dev(source, period, s, a, i)
y1 = low - (ta.atr(30) * 2), y1B = low - ta.atr(30)
y2 = high + (ta.atr(30) * 2), y2B = high + ta.atr(30)
x1 = bar_index - period + 1, _y1 = i + s * (period - 1), x2 = bar_index, _y2 = i
//Functions
//Line Style function
get_line_style(style) =>
out = switch style
'???' => line.style_solid
'----' => line.style_dashed
' ' => line.style_dotted
//Function to get order block coordinates
get_coordinates(condition, top, btm, ob_val)=>
var ob_top = array.new_float(0)
var ob_btm = array.new_float(0)
var ob_avg = array.new_float(0)
var ob_left = array.new_int(0)
float ob = na
//Append coordinates to arrays
if condition
avg = math.avg(top, btm)
array.unshift(ob_top, top)
array.unshift(ob_btm, btm)
array.unshift(ob_avg, avg)
ob := ob_val
//Function to remove mitigated order blocks from coordinate arrays
remove_mitigated(ob_top, ob_btm, ob_left, ob_avg, target, bull)=>
mitigated = false
target_array = bull ? ob_btm : ob_top
for element in target_array
idx = array.indexof(target_array, element)
if (bull ? target < element : target > element)
mitigated := true
array.remove(ob_top, idx)
array.remove(ob_btm, idx)
array.remove(ob_avg, idx)
array.remove(ob_left, idx)
mitigated
//Function to set order blocks
set_order_blocks(ob_top, ob_btm, ob_left, ob_avg, ext_last, bg_css, border_css, lvl_css)=>
var ob_box = array.new_box(0)
var ob_lvl = array.new_line(0)
//Global elements
var os = 0
var target_bull = 0.
var target_bear = 0.
// Create non-repainting security function
rp_security(_symbol, _res, _src) =>
request.security(_symbol, _res, _src )
htfHigh = rp_security(syminfo.tickerid, res, high)
htfLow = rp_security(syminfo.tickerid, res, low)
// Main Indicator
// Functions
smoothrng(x, t, m) =>
wper = t * 2 - 1
avrng = ta.ema(math.abs(x - x ), t)
smoothrng = ta.ema(avrng, wper) * m
rngfilt(x, r) =>
rngfilt = x
rngfilt := x > nz(rngfilt ) ? x - r < nz(rngfilt ) ? nz(rngfilt ) : x - r : x + r > nz(rngfilt ) ? nz(rngfilt ) : x + r
percWidth(len, perc) => (ta.highest(len) - ta.lowest(len)) * perc / 100
securityNoRep(sym, res, src) => request.security(sym, res, src, barmerge.gaps_off, barmerge.lookahead_on)
swingPoints(prd) =>
pivHi = ta.pivothigh(prd, prd)
pivLo = ta.pivotlow (prd, prd)
last_pivHi = ta.valuewhen(pivHi, pivHi, 1)
last_pivLo = ta.valuewhen(pivLo, pivLo, 1)
hh = pivHi and pivHi > last_pivHi ? pivHi : na
lh = pivHi and pivHi < last_pivHi ? pivHi : na
hl = pivLo and pivLo > last_pivLo ? pivLo : na
ll = pivLo and pivLo < last_pivLo ? pivLo : na
f_chartTfInMinutes() =>
float _resInMinutes = timeframe.multiplier * (
timeframe.isseconds ? 1 :
timeframe.isminutes ? 1. :
timeframe.isdaily ? 60. * 24 :
timeframe.isweekly ? 60. * 24 * 7 :
timeframe.ismonthly ? 60. * 24 * 30.4375 : na)
f_kc(src, len, sensitivity) =>
basis = ta.sma(src, len)
span = ta.atr(len)
wavetrend(src, chlLen, avgLen) =>
esa = ta.ema(src, chlLen)
d = ta.ema(math.abs(src - esa), chlLen)
ci = (src - esa) / (0.015 * d)
wt1 = ta.ema(ci, avgLen)
wt2 = ta.sma(wt1, 3)
f_top_fractal(_src) => _src < _src and _src < _src and _src > _src and _src > _src
f_bot_fractal(_src) => _src > _src and _src > _src and _src < _src and _src < _src
top_fractal = f_top_fractal(src)
bot_fractal = f_bot_fractal(src)
f_fractalize (_src) => top_fractal ? 1 : bot_fractal ? -1 : 0
f_findDivs(src, topLimit, botLimit) =>
fractalTop = f_fractalize(src) > 0 and src >= topLimit ? src : na
fractalBot = f_fractalize(src) < 0 and src <= botLimit ? src : na
highPrev = ta.valuewhen(fractalTop, src , 0)
highPrice = ta.valuewhen(fractalTop, high , 0)
lowPrev = ta.valuewhen(fractalBot, src , 0)
lowPrice = ta.valuewhen(fractalBot, low , 0)
bearSignal = fractalTop and high > highPrice and src < highPrev
bullSignal = fractalBot and low < lowPrice and src > lowPrev
// Get user input
enableSR = input(false , "SR On/Off", group="SR")
colorSup = input(#00000000 , "Support Color", group="SR")
colorRes = input(#00000000 , "Resistance Color", group="SR")
strengthSR = input.int(2 , "S/R Strength", 1, group="SR")
lineStyle = input.string("Dotted", "Line Style", , group="SR")
lineWidth = input.int(2 , "S/R Line Width", 1, group="SR")
useZones = input(true , "Zones On/Off", group="SR")
useHLZones = input(true , "High Low Zones On/Off", group="SR")
zoneWidth = input.int(2 , "Zone Width %", 0,
tooltip = "it's calculated using % of the distance between highest/lowest in last 300 bars", group="SR")
expandSR = input(true , "Expand SR")
// Get components
rb = 10
prd = 284
ChannelW = 10
label_loc = 55
style = lineStyle == "Solid" ? line.style_solid :
lineStyle == "Dotted" ? line.style_dotted : line.style_dashed
ph = ta.pivothigh(rb, rb)
pl = ta.pivotlow (rb, rb)
sr_levels = array.new_float(21, na)
prdhighest = ta.highest(prd)
prdlowest = ta.lowest(prd)
cwidth = percWidth(prd, ChannelW)
zonePerc = percWidth(300, zoneWidth)
aas = array.new_bool(41, true)
u1 = 0.0, u1 := nz(u1 )
d1 = 0.0, d1 := nz(d1 )
highestph = 0.0, highestph := highestph
lowestpl = 0.0, lowestpl := lowestpl
var sr_levs = array.new_float(21, na)
label hlabel = na, label.delete(hlabel )
label llabel = na, label.delete(llabel )
var sr_lines = array.new_line(21, na)
var sr_linesH = array.new_line(21, na)
var sr_linesL = array.new_line(21, na)
var sr_linesF = array.new_linefill(21, na)
var sr_labels = array.new_label(21, na)
if (not na(ph) or not na(pl))
for x = 0 to array.size(sr_levels) - 1
array.set(sr_levels, x, na)
highestph := prdlowest
lowestpl := prdhighest
countpp = 0
for x = 0 to prd
if na(close )
break
if not na(ph ) or not na(pl )
highestph := math.max(highestph, nz(ph , prdlowest), nz(pl , prdlowest))
lowestpl := math.min(lowestpl, nz(ph , prdhighest), nz(pl , prdhighest))
countpp += 1
if countpp > 40
break
if array.get(aas, countpp)
upl = (not na(ph ) and (ph != 0) ? high : low ) + cwidth
dnl = (not na(ph ) and (ph != 0) ? high : low ) - cwidth
u1 := countpp == 1 ? upl : u1
d1 := countpp == 1 ? dnl : d1
tmp = array.new_bool(41, true)
cnt = 0
tpoint = 0
for xx = 0 to prd
if na(close )
break
if not na(ph ) or not na(pl )
chg = false
cnt += 1
if cnt > 40
break
if array.get(aas, cnt)
if not na(ph )
if high <= upl and high >= dnl
tpoint += 1
chg := true
if not na(pl )
if low <= upl and low >= dnl
tpoint += 1
chg := true
if chg and cnt < 41
array.set(tmp, cnt, false)
if tpoint >= strengthSR
for g = 0 to 40 by 1
if not array.get(tmp, g)
array.set(aas, g, false)
if (not na(ph ) and countpp < 21)
array.set(sr_levels, countpp, high )
if (not na(pl ) and countpp < 21)
array.set(sr_levels, countpp, low )
// Plot
var line highest_ = na, line.delete(highest_)
var line lowest_ = na, line.delete(lowest_)
var line highest_fill1 = na, line.delete(highest_fill1)
var line highest_fill2 = na, line.delete(highest_fill2)
var line lowest_fill1 = na, line.delete(lowest_fill1)
var line lowest_fill2 = na, line.delete(lowest_fill2)
hi_col = close >= highestph ? colorSup : colorRes
lo_col = close >= lowestpl ? colorSup : colorRes
if enableSR
highest_ := line.new(bar_index - 311, highestph, bar_index, highestph, xloc.bar_index, expandSR ? extend.both : extend.right, hi_col, style, lineWidth)
lowest_ := line.new(bar_index - 311, lowestpl , bar_index, lowestpl , xloc.bar_index, expandSR ? extend.both : extend.right, lo_col, style, lineWidth)
if useHLZones
highest_fill1 := line.new(bar_index - 311, highestph + zonePerc, bar_index, highestph + zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na)
highest_fill2 := line.new(bar_index - 311, highestph - zonePerc, bar_index, highestph - zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na)
lowest_fill1 := line.new(bar_index - 311, lowestpl + zonePerc , bar_index, lowestpl + zonePerc , xloc.bar_index, expandSR ? extend.both : extend.right, na)
lowest_fill2 := line.new(bar_index - 311, lowestpl - zonePerc , bar_index, lowestpl - zonePerc , xloc.bar_index, expandSR ? extend.both : extend.right, na)
linefill.new(highest_fill1, highest_fill2, hi_col)
linefill.new(lowest_fill1 , lowest_fill2 , lo_col)
if (not na(ph) or not na(pl))
for x = 0 to array.size(sr_lines) - 1
array.set(sr_levs, x, array.get(sr_levels, x))
for x = 0 to array.size(sr_lines) - 1
line.delete(array.get(sr_lines, x))
line.delete(array.get(sr_linesH, x))
line.delete(array.get(sr_linesL, x))
linefill.delete(array.get(sr_linesF, x))
if (not na(array.get(sr_levs, x)) and enableSR)
line_col = close >= array.get(sr_levs, x) ? colorSup : colorRes
array.set(sr_lines, x, line.new(bar_index - 355, array.get(sr_levs, x), bar_index, array.get(sr_levs, x), xloc.bar_index, expandSR ? extend.both : extend.right, line_col, style, lineWidth))
if useZones
array.set(sr_linesH, x, line.new(bar_index - 355, array.get(sr_levs, x) + zonePerc, bar_index, array.get(sr_levs, x) + zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na))
array.set(sr_linesL, x, line.new(bar_index - 355, array.get(sr_levs, x) - zonePerc, bar_index, array.get(sr_levs, x) - zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na))
array.set(sr_linesF, x, linefill.new(array.get(sr_linesH, x), array.get(sr_linesL, x), line_col))
for x = 0 to array.size(sr_labels) - 1
label.delete(array.get(sr_labels, x))
if (not na(array.get(sr_levs, x)) and enableSR)
lab_loc = close >= array.get(sr_levs, x) ? label.style_label_up : label.style_label_down
lab_col = close >= array.get(sr_levs, x) ? colorSup : colorRes
array.set(sr_labels, x, label.new(bar_index + label_loc, array.get(sr_levs, x), str.tostring(math.round_to_mintick(array.get(sr_levs, x))), color=lab_col , textcolor=#000000, style=lab_loc))
hlabel := enableSR ? label.new(bar_index + label_loc + math.round(math.sign(label_loc)) * 20, highestph, "High Level : " + str.tostring(highestph), color=hi_col, textcolor=#000000, style=label.style_label_down) : na
llabel := enableSR ? label.new(bar_index + label_loc + math.round(math.sign(label_loc)) * 20, lowestpl , "Low Level : " + str.tostring(lowestpl) , color=lo_col, textcolor=#000000, style=label.style_label_up ) : na
// Get components
rsi = ta.rsi(close, 28)
//rsiOb = rsi > 78 and rsi > ta.ema(rsi, 10)
//rsiOs = rsi < 27 and rsi < ta.ema(rsi, 10)
rsiOb = rsi > 65 and rsi > ta.ema(rsi, 10)
rsiOs = rsi < 35 and rsi < ta.ema(rsi, 10)
dHigh = securityNoRep(syminfo.tickerid, "D", high )
dLow = securityNoRep(syminfo.tickerid, "D", low )
dClose = securityNoRep(syminfo.tickerid, "D", close )
ema = ta.ema(close, 144)
emaBull = close > ema
equal_tf(res) => str.tonumber(res) == f_chartTfInMinutes() and not timeframe.isseconds
higher_tf(res) => str.tonumber(res) > f_chartTfInMinutes() or timeframe.isseconds
too_small_tf(res) => (timeframe.isweekly and res=="1") or (timeframe.ismonthly and str.tonumber(res) < 10)
securityNoRep1(sym, res, src) =>
bool bull_ = na
bull_ := equal_tf(res) ? src : bull_
bull_ := higher_tf(res) ? request.security(sym, res, src, barmerge.gaps_off, barmerge.lookahead_on) : bull_
bull_array = request.security_lower_tf(syminfo.tickerid, higher_tf(res) ? str.tostring(f_chartTfInMinutes()) + (timeframe.isseconds ? "S" : "") : too_small_tf(res) ? (timeframe.isweekly ? "3" : "10") : res, src)
if array.size(bull_array) > 1 and not equal_tf(res) and not higher_tf(res)
bull_ := array.pop(bull_array)
array.clear(bull_array)
bull_
// === BASE FUNCTIONS ===
// Returns MA input selection variant, default to SMA if blank or typo.
variant(type, src, len, offSig, offALMA) =>
v1 = ta.sma(src, len) // Simple
v2 = ta.ema(src, len) // Exponential
v3 = 2 * v2 - ta.ema(v2, len) // Double Exponential
v4 = 3 * (v2 - ta.ema(v2, len)) + ta.ema(ta.ema(v2, len), len) // Triple Exponential
v5 = ta.wma(src, len) // Weighted
v6 = ta.vwma(src, len) // Volume Weighted
v7 = 0.0
sma_1 = ta.sma(src, len) // Smoothed
v7 := na(v7 ) ? sma_1 : (v7 * (len - 1) + src) / len
v8 = ta.wma(2 * ta.wma(src, len / 2) - ta.wma(src, len), math.round(math.sqrt(len))) // Hull
v9 = ta.linreg(src, len, offSig) // Least Squares
v10 = ta.alma(src, len, offALMA, offSig) // Arnaud Legoux
v11 = ta.sma(v1, len) // Triangular (extreme smooth)
// SuperSmoother filter
// 2013 John F. Ehlers
a1 = math.exp(-1.414 * 3.14159 / len)
b1 = 2 * a1 * math.cos(1.414 * 3.14159 / len)
c2 = b1
c3 = -a1 * a1
c1 = 1 - c2 - c3
v12 = 0.0
v12 := c1 * (src + nz(src )) / 2 + c2 * nz(v12 ) + c3 * nz(v12 )
type == 'EMA' ? v2 : type == 'DEMA' ? v3 : type == 'TEMA' ? v4 : type == 'WMA' ? v5 : type == 'VWMA' ? v6 : type == 'SMMA' ? v7 : type == 'HullMA' ? v8 : type == 'LSMA' ? v9 : type == 'ALMA' ? v10 : type == 'TMA' ? v11 : type == 'SSMA' ? v12 : v1
// security wrapper for repeat calls
reso(exp, use, res) =>
security_1 = request.security(syminfo.tickerid, res, exp, gaps = barmerge.gaps_off, lookahead = barmerge.lookahead_on)
use ? security_1 : exp
// === /BASE FUNCTIONS ===
// === SERIES SETUP ===
closeSeries = variant(basisType, close , basisLen, offsetSigma, offsetALMA)
openSeries = variant(basisType, open , basisLen, offsetSigma, offsetALMA)
// === /SERIES ===
// Get Alternate resolution Series if selected.
closeSeriesAlt = reso(closeSeries, useRes, stratRes)
openSeriesAlt = reso(openSeries, useRes, stratRes)
//
lxTrigger = false
sxTrigger = false
leTrigger = ta.crossover (closeSeriesAlt, openSeriesAlt)
seTrigger = ta.crossunder(closeSeriesAlt, openSeriesAlt)
G_RISK = '■ ' + 'Risk Management'
//#region ———— <↓↓↓ G_RISK ↓↓↓> {
// ———————————
//Tooltip
T_LVL = '(%) Exit Level'
T_QTY = '(%) Adjust trade exit volume'
T_MSG = 'Paste JSON message for your bot'
//Webhook Message
O_LEMSG = 'Long Entry'
O_LXMSGSL = 'Long SL'
O_LXMSGTP1 = 'Long TP1'
O_LXMSGTP2 = 'Long TP2'
O_LXMSGTP3 = 'Long TP3'
O_LXMSG = 'Long Exit'
O_SEMSG = 'Short Entry'
O_SXMSGSL = 'Short SL'
O_SXMSGA = 'Short TP1'
O_SXMSGB = 'Short TP2'
O_SXMSGC = 'Short TP3'
O_SXMSGX = 'Short Exit'
// ——————————— | | | Line length guide |
i_lxLvlTP1 = input.float (0.2, 'Level TP1' , group = G_RISK,
tooltip = T_LVL)
i_lxQtyTP1 = input.float (80.0, 'Qty TP1' , group = G_RISK,
tooltip = T_QTY)
i_lxLvlTP2 = input.float (0.5, 'Level TP2' , group = G_RISK,
tooltip = T_LVL)
i_lxQtyTP2 = input.float (10.0, 'Qty TP2' , group = G_RISK,
tooltip = T_QTY)
i_lxLvlTP3 = input.float (7.0, 'Level TP3' , group = G_RISK,
tooltip = T_LVL)
i_lxQtyTP3 = input.float (2, 'Qty TP3' , group = G_RISK,
tooltip = T_QTY)
i_lxLvlSL = input.float (0.5, 'Stop Loss' , group = G_RISK,
tooltip = T_LVL)
i_sxLvlTP1 = i_lxLvlTP1
i_sxQtyTP1 = i_lxQtyTP1
i_sxLvlTP2 = i_lxLvlTP2
i_sxQtyTP2 = i_lxQtyTP2
i_sxLvlTP3 = i_lxLvlTP3
i_sxQtyTP3 = i_lxQtyTP3
i_sxLvlSL = i_lxLvlSL
G_MSG = '■ ' + 'Webhook Message'
i_leMsg = input.string (O_LEMSG ,'Long Entry' , group = G_MSG, tooltip = T_MSG)
i_lxMsgSL = input.string (O_LXMSGSL ,'Long SL' , group = G_MSG, tooltip = T_MSG)
i_lxMsgTP1 = input.string (O_LXMSGTP1,'Long TP1' , group = G_MSG, tooltip = T_MSG)
i_lxMsgTP2 = input.string (O_LXMSGTP2,'Long TP2' , group = G_MSG, tooltip = T_MSG)
i_lxMsgTP3 = input.string (O_LXMSGTP3,'Long TP3' , group = G_MSG, tooltip = T_MSG)
i_lxMsg = input.string (O_LXMSG ,'Long Exit' , group = G_MSG, tooltip = T_MSG)
i_seMsg = input.string (O_SEMSG ,'Short Entry' , group = G_MSG, tooltip = T_MSG)
i_sxMsgSL = input.string (O_SXMSGSL ,'Short SL' , group = G_MSG, tooltip = T_MSG)
i_sxMsgTP1 = input.string (O_SXMSGA ,'Short TP1' , group = G_MSG, tooltip = T_MSG)
i_sxMsgTP2 = input.string (O_SXMSGB ,'Short TP2' , group = G_MSG, tooltip = T_MSG)
i_sxMsgTP3 = input.string (O_SXMSGC ,'Short TP3' , group = G_MSG, tooltip = T_MSG)
i_sxMsg = input.string (O_SXMSGX ,'Short Exit' , group = G_MSG, tooltip = T_MSG)
i_src = close
G_DISPLAY = 'Display'
//
i_alertOn = input.bool (true, 'Alert Labels On/Off' , group = G_DISPLAY)
i_barColOn = input.bool (true, 'Bar Color On/Off' , group = G_DISPLAY)
// ———————————
// @function Calculate the Take Profit line, and the crossover or crossunder
f_tp(_condition, _conditionValue, _leTrigger, _seTrigger, _src, _lxLvlTP, _sxLvlTP)=>
var float _tpLine = 0.0
_topLvl = _src + (_src * (_lxLvlTP / 100))
_botLvl = _src - (_src * (_sxLvlTP / 100))
_tpLine := _condition != _conditionValue and _leTrigger ? _topLvl :
_condition != -_conditionValue and _seTrigger ? _botLvl :
nz(_tpLine )
// @function Similar to "ta.crossover" or "ta.crossunder"
f_cross(_scr1, _scr2, _over)=>
_cross = _over ? _scr1 > _scr2 and _scr1 < _scr2 :
_scr1 < _scr2 and _scr1 > _scr2
// ———————————
//
var float condition = 0.0
var float slLine = 0.0
var float entryLine = 0.0
//
entryLine := leTrigger and condition <= 0.0 ? close :
seTrigger and condition >= 0.0 ? close : nz(entryLine )
//
slTopLvl = i_src + (i_src * (i_lxLvlSL / 100))
slBotLvl = i_src - (i_src * (i_sxLvlSL / 100))
slLine := condition <= 0.0 and leTrigger ? slBotLvl :
condition >= 0.0 and seTrigger ? slTopLvl : nz(slLine )
slLong = f_cross(low, slLine, false)
slShort = f_cross(high, slLine, true )
//
= f_tp(condition, 1.2,leTrigger, seTrigger, i_src, i_lxLvlTP3, i_sxLvlTP3)
= f_tp(condition, 1.1,leTrigger, seTrigger, i_src, i_lxLvlTP2, i_sxLvlTP2)
= f_tp(condition, 1.0,leTrigger, seTrigger, i_src, i_lxLvlTP1, i_sxLvlTP1)
tp3Long = f_cross(high, tp3Line, true )
tp3Short = f_cross(low, tp3Line, false)
tp2Long = f_cross(high, tp2Line, true )
tp2Short = f_cross(low, tp2Line, false)
tp1Long = f_cross(high, tp1Line, true )
tp1Short = f_cross(low, tp1Line, false)
switch
leTrigger and condition <= 0.0 => condition := 1.0
seTrigger and condition >= 0.0 => condition := -1.0
tp3Long and condition == 1.2 => condition := 1.3
tp3Short and condition == -1.2 => condition := -1.3
tp2Long and condition == 1.1 => condition := 1.2
tp2Short and condition == -1.1 => condition := -1.2
tp1Long and condition == 1.0 => condition := 1.1
tp1Short and condition == -1.0 => condition := -1.1
slLong and condition >= 1.0 => condition := 0.0
slShort and condition <= -1.0 => condition := 0.0
lxTrigger and condition >= 1.0 => condition := 0.0
sxTrigger and condition <= -1.0 => condition := 0.0
longE = leTrigger and condition <= 0.0 and condition == 1.0
shortE = seTrigger and condition >= 0.0 and condition == -1.0
longX = lxTrigger and condition >= 1.0 and condition == 0.0
shortX = sxTrigger and condition <= -1.0 and condition == 0.0
longSL = slLong and condition >= 1.0 and condition == 0.0
shortSL = slShort and condition <= -1.0 and condition == 0.0
longTP3 = tp3Long and condition == 1.2 and condition == 1.3
shortTP3 = tp3Short and condition == -1.2 and condition == -1.3
longTP2 = tp2Long and condition == 1.1 and condition == 1.2
shortTP2 = tp2Short and condition == -1.1 and condition == -1.2
longTP1 = tp1Long and condition == 1.0 and condition == 1.1
shortTP1 = tp1Short and condition == -1.0 and condition == -1.1
// ——————————— {
//
if strategy.position_size <= 0 and longE and barstate.isconfirmed
strategy.entry(
'Long',
strategy.long,
alert_message = i_leMsg,
comment = 'LE')
if strategy.position_size > 0 and condition == 1.0
strategy.exit(
id = 'LXTP1',
from_entry = 'Long',
qty_percent = i_lxQtyTP1,
limit = tp1Line,
stop = slLine,
comment_profit = 'LXTP1',
comment_loss = 'SL',
alert_profit = i_lxMsgTP1,
alert_loss = i_lxMsgSL)
if strategy.position_size > 0 and condition == 1.1
strategy.exit(
id = 'LXTP2',
from_entry = 'Long',
qty_percent = i_lxQtyTP2,
limit = tp2Line,
stop = slLine,
comment_profit = 'LXTP2',
comment_loss = 'SL',
alert_profit = i_lxMsgTP2,
alert_loss = i_lxMsgSL)
if strategy.position_size > 0 and condition == 1.2
strategy.exit(
id = 'LXTP3',
from_entry = 'Long',
qty_percent = i_lxQtyTP3,
limit = tp3Line,
stop = slLine,
comment_profit = 'LXTP3',
comment_loss = 'SL',
alert_profit = i_lxMsgTP3,
alert_loss = i_lxMsgSL)
if longX
strategy.close(
'Long',
alert_message = i_lxMsg,
comment = 'LX')
//
if strategy.position_size >= 0 and shortE and barstate.isconfirmed
strategy.entry(
'Short',
strategy.short,
alert_message = i_leMsg,
comment = 'SE')
if strategy.position_size < 0 and condition == -1.0
strategy.exit(
id = 'SXTP1',
from_entry = 'Short',
qty_percent = i_sxQtyTP1,
limit = tp1Line,
stop = slLine,
comment_profit = 'SXTP1',
comment_loss = 'SL',
alert_profit = i_sxMsgTP1,
alert_loss = i_sxMsgSL)
if strategy.position_size < 0 and condition == -1.1
strategy.exit(
id = 'SXTP2',
from_entry = 'Short',
qty_percent = i_sxQtyTP2,
limit = tp2Line,
stop = slLine,
comment_profit = 'SXTP2',
comment_loss = 'SL',
alert_profit = i_sxMsgTP2,
alert_loss = i_sxMsgSL)
if strategy.position_size < 0 and condition == -1.2
strategy.exit(
id = 'SXTP3',
from_entry = 'Short',
qty_percent = i_sxQtyTP3,
limit = tp3Line,
stop = slLine,
comment_profit = 'SXTP3',
comment_loss = 'SL',
alert_profit = i_sxMsgTP3,
alert_loss = i_sxMsgSL)
if shortX
strategy.close(
'Short',
alert_message = i_sxMsg,
comment = 'SX')
// ———————————
c_tp = leTrigger or seTrigger ? na :
condition == 0.0 ? na : color.green
c_entry = leTrigger or seTrigger ? na :
condition == 0.0 ? na : color.blue
c_sl = leTrigger or seTrigger ? na :
condition == 0.0 ? na : color.red
p_tp1Line = plot (
condition == 1.0 or
condition == -1.0 ? tp1Line : na,
title = "TP Line 1",
color = c_tp,
linewidth = 1,
style = plot.style_linebr)
p_tp2Line = plot (
condition == 1.0 or
condition == -1.0 or
condition == 1.1 or
condition == -1.1 ? tp2Line : na,
title = "TP Line 2",
color = c_tp,
linewidth = 1,
style = plot.style_linebr)
p_tp3Line = plot (
condition == 1.0 or
condition == -1.0 or
condition == 1.1 or
condition == -1.1 or
condition == 1.2 or
condition == -1.2 ? tp3Line : na,
title = "TP Line 3",
color = c_tp,
linewidth = 1,
style = plot.style_linebr)
p_entryLine = plot (
condition >= 1.0 or
condition <= -1.0 ? entryLine : na,
title = "Entry Line",
color = c_entry,
linewidth = 1,
style = plot.style_linebr)
p_slLine = plot (
condition == 1.0 or
condition == -1.0 or
condition == 1.1 or
condition == -1.1 or
condition == 1.2 or
condition == -1.2 ? slLine : na,
title = "SL Line",
color = c_sl,
linewidth = 1,
style = plot.style_linebr)
fill(
p_tp3Line, p_entryLine,
color = leTrigger or seTrigger ? na :color.new(color.green, 90))
fill(
p_entryLine, p_slLine,
color = leTrigger or seTrigger ? na :color.new(color.red, 90))
//
plotshape(
i_alertOn and longE,
title = 'Long',
text = 'Long',
textcolor = color.white,
color = color.green,
style = shape.labelup,
size = size.tiny,
location = location.belowbar)
plotshape(
i_alertOn and shortE,
title = 'Short',
text = 'Short',
textcolor = color.white,
color = color.red,
style = shape.labeldown,
size = size.tiny,
location = location.abovebar)
plotshape(
i_alertOn and (longX or shortX) ? close : na,
title = 'Close',
text = 'Close',
textcolor = color.white,
color = color.gray,
style = shape.labelup,
size = size.tiny,
location = location.absolute)
l_tp = i_alertOn and (longTP1 or shortTP1) ? close : na
plotshape(
l_tp,
title = "TP1 Cross",
text = "TP1",
textcolor = color.white,
color = color.olive,
style = shape.labelup,
size = size.tiny,
location = location.absolute)
plotshape(
i_alertOn and (longTP2 or shortTP2) ? close : na,
title = "TP2 Cross",
text = "TP2",
textcolor = color.white,
color = color.olive,
style = shape.labelup,
size = size.tiny,
location = location.absolute)
plotshape(
i_alertOn and (longTP3 or shortTP3) ? close : na,
title = "TP3 Cross",
text = "TP3",
textcolor = color.white,
color = color.olive,
style = shape.labelup,
size = size.tiny,
location = location.absolute)
plotshape(
i_alertOn and (longSL or shortSL) ? close : na,
title = "SL Cross",
text = "SL",
textcolor = color.white,
color = color.maroon,
style = shape.labelup,
size = size.tiny,
location = location.absolute)
//
plot(
na,
title = "─── ───",
editable = false,
display = display.data_window)
plot(
condition,
title = "condition",
editable = false,
display = display.data_window)
plot(
strategy.position_size * 100,
title = ".position_size",
editable = false,
display = display.data_window)
//#endregion }
// ——————————— <↑↑↑ G_RISK ↑↑↑>
//#region ———— <↓↓↓ G_SCRIPT02 ↓↓↓> {
// @function Queues a new element in an array and de-queues its first element.
f_qDq(_array, _val) =>
array.push(_array, _val)
_return = array.shift(_array)
_return
var line a_slLine = array.new_line(1)
var line a_entryLine = array.new_line(1)
var line a_tp3Line = array.new_line(1)
var line a_tp2Line = array.new_line(1)
var line a_tp1Line = array.new_line(1)
var label a_slLabel = array.new_label(1)
var label a_tp3label = array.new_label(1)
var label a_tp2label = array.new_label(1)
var label a_tp1label = array.new_label(1)
var label a_entryLabel = array.new_label(1)
newEntry = longE or shortE
entryIndex = 1
entryIndex := newEntry ? bar_index : nz(entryIndex )
lasTrade = bar_index >= entryIndex
l_right = 10
line.delete(
f_qDq(a_slLine,
line.new(
entryIndex,
slLine,
last_bar_index + l_right,
slLine,
style = line.style_solid,
color = c_sl)))
line.delete(
f_qDq(a_entryLine,
line.new(
entryIndex,
entryLine,
last_bar_index + l_right,
entryLine,
style = line.style_solid,
color = color.blue)))
line.delete(
f_qDq(a_tp3Line,
line.new(
entryIndex,
tp3Line,
last_bar_index + l_right,
tp3Line,
style = line.style_solid,
color = c_tp)))
line.delete(
f_qDq(a_tp2Line,
line.new(
entryIndex,
tp2Line,
last_bar_index + l_right,
tp2Line,
style = line.style_solid,
color = c_tp)))
line.delete(
f_qDq(a_tp1Line,
line.new(
entryIndex,
tp1Line,
last_bar_index + l_right,
tp1Line,
style = line.style_solid,
color = c_tp)))
label.delete(
f_qDq(a_slLabel,
label.new(
last_bar_index + l_right,
slLine,
'SL: ' + str.tostring(slLine, '##.###'),
style = label.style_label_left,
textcolor = color.white,
color = c_sl)))
label.delete(
f_qDq(a_entryLabel,
label.new(
last_bar_index + l_right,
entryLine,
'Entry: ' + str.tostring(entryLine, '##.###'),
style = label.style_label_left,
textcolor = color.white,
color = color.blue)))
label.delete(
f_qDq(a_tp3label,
label.new(
last_bar_index + l_right,
tp3Line,
'TP3: ' + str.tostring(tp3Line, '##.###'),
style = label.style_label_left,
textcolor = color.white,
color = c_tp)))
label.delete(
f_qDq(a_tp2label,
label.new(
last_bar_index + l_right,
tp2Line,
'TP2: ' + str.tostring(tp2Line, '##.###'),
style = label.style_label_left,
textcolor = color.white,
color = c_tp)))
label.delete(
f_qDq(a_tp1label,
label.new(
last_bar_index + l_right,
tp1Line,
'TP1: ' + str.tostring(tp1Line, '##.###'),
style = label.style_label_left,
textcolor = color.white,
color = c_tp)))
// ———————————
//
if longE or shortE or longX or shortX
alert(message = 'Any Alert', freq = alert.freq_once_per_bar_close)
if longE
alert(message = 'Long Entry', freq = alert.freq_once_per_bar_close)
if shortE
alert(message = 'Short Entry', freq = alert.freq_once_per_bar_close)
if longX
alert(message = 'Long Exit', freq = alert.freq_once_per_bar_close)
if shortX
alert(message = 'Short Exit', freq = alert.freq_once_per_bar_close)
//#endregion }
// ——————————— <↑↑↑ G_SCRIPT03 ↑↑↑>
SMC Alpha Engine [PhenLabs]📊 SMC Alpha Engine
Version: PineScript™ v6
📌 Description
The SMC Alpha Engine is a comprehensive Smart Money Concepts indicator that automates institutional trading pattern recognition. Built for traders who understand that confluence is king, this indicator stacks multiple SMC elements together and scores them in real-time, allowing you to focus exclusively on high-probability setups.
Rather than manually tracking HTF bias, market structure, liquidity levels, order blocks, and fair value gaps separately, the SMC Alpha Engine consolidates everything into a unified scoring system. When enough factors align, you get a signal. When they don’t, you wait. This systematic approach removes emotion and subjectivity from SMC trading.
The indicator is designed around one core principle: only trade when the probabilities are stacked in your favor. By requiring multiple confluence factors before generating signals, it filters out the noise and keeps you focused on setups that institutional traders actually care about.
🚀 Points of Innovation
Automated confluence scoring system that evaluates 6 distinct SMC factors in real-time
HTF-to-LTF bias alignment ensuring trades flow with institutional direction
Intelligent liquidity sweep detection using wick-ratio analysis for confirmation
ATR-based FVG quality filtering that eliminates noise and shows only significant imbalances
Anti-spam signal logic preventing overtrading during volatile market conditions
Session-aware killzone integration timing entries with institutional activity windows
🔧 Core Components
HTF Bias Engine: Analyzes higher timeframe swing structure to establish directional bias using pivot high/low comparisons
Market Structure Module: Detects BOS (Break of Structure) and CHoCH (Change of Character) with real-time confirmation
Premium/Discount Calculator: Dynamically maps price zones relative to recent swing range equilibrium
Liquidity Tracker: Monitors swing points as liquidity targets and identifies sweep events with rejection confirmation
POI Detector: Identifies valid Order Blocks with displacement requirements and Fair Value Gaps with ATR filtering
Confluence Scorer: Aggregates all factors into bull/bear scores displayed on real-time dashboard
🔥 Key Features
Multi-timeframe analysis combining HTF directional bias with LTF precision entries
Customizable confluence threshold from 1 (low filter) to 5 (sniper mode)
Three killzone sessions: London (02:00-05:00), NY AM (08:30-11:00), NY PM (13:30-16:00)
Flexible mitigation options for OBs and FVGs: Wick, Close, 50%, or None
Visual structure labeling for BOS and CHoCH events on chart
Real-time info dashboard showing all current market conditions and scores
Built-in alert conditions for BOS, liquidity sweeps, and high-confluence signals
🎨 Visualization
Premium Zone: Red-tinted box above equilibrium indicating sell-side interest areas
Discount Zone: Green-tinted box below equilibrium indicating buy-side interest areas
Equilibrium Line: Dotted gray line marking the 50% level of current range
Order Blocks: Color-coded boxes (green for bullish, red for bearish) showing institutional candles
Fair Value Gaps: Teal boxes for bullish FVGs, maroon boxes for bearish FVGs
Killzone Backgrounds: Blue (London), Orange (NY AM), Purple (NY PM) session highlighting
Info Table: Top-right dashboard displaying HTF bias, LTF trend, zone, killzone status, and scores
📖 Usage Guidelines
HTF Settings
HTF Timeframe - Default: 60 - Controls higher timeframe for directional bias
HTF Swing Length - Default: 10, Range: 3+ - Determines pivot sensitivity for HTF trend
Market Structure Settings
LTF Swing Length - Default: 3, Range: 1-10 - Controls swing detection sensitivity
Show BOS/CHoCH - Default: Off - Toggles structure labels on chart
Show Strong/Weak Points - Default: Off - Displays swing point classifications
POI Settings
Show Valid Order Blocks - Default: Off - Displays OBs that caused displacement
Show Unmitigated FVGs - Default: On - Shows active fair value gaps
Filter FVG by ATR - Default: On - Only shows FVGs larger than 0.5x ATR
OB Mitigation Type - Options: Wick, Close, None - Determines when OBs are invalidated
FVG Mitigation Type - Options: Wick, Close, 50%, None - Determines when FVGs are filled
Confluence Settings
Minimum Score for Signal - Default: 4, Range: 1-5 - Required confluence level for entries
Show Entry Signals - Default: On - Toggles LONG/SHORT labels on chart
✅ Best Use Cases
Trend continuation trades during active killzone sessions with HTF alignment
Discount zone entries on bullish HTF bias with recent liquidity sweep below
Premium zone shorts on bearish HTF bias after liquidity grab above recent highs
Reversal identification following CHoCH with POI confluence in optimal zone
Filtering existing strategy signals by requiring minimum confluence score
⚠️ Limitations
HTF bias detection requires sufficient price history for accurate pivot identification
Liquidity sweep detection depends on wick-ratio settings and may miss some events
Order blocks require displacement confirmation which may exclude some valid zones
Confluence scoring is probabilistic and does not guarantee profitable outcomes
Killzone times are based on EST/EDT and require timezone adjustment for other regions
Signal spam prevention may delay valid signals by up to 10 bars after previous signal
💡 What Makes This Unique
Unified SMC Framework: Combines all major SMC concepts into one cohesive indicator rather than requiring multiple tools
Objective Scoring System: Removes subjectivity by quantifying confluence into measurable scores
Institutional Timing Integration: Built-in killzone awareness ensures signals align with high-volume sessions
Quality Filtering: ATR-based FVG filtering and displacement-required OBs eliminate low-quality setups
Anti-Overtrading Logic: Smart signal spacing prevents emotional trading during choppy conditions
🔬 How It Works
Step 1: HTF Bias Determination
Analyzes higher timeframe pivot highs and lows
Compares consecutive pivots to identify HH/HL (bullish) or LH/LL (bearish) sequences
Establishes directional filter that all signals must respect
Step 2: LTF Structure Mapping
Detects swing points on execution timeframe
Identifies BOS when price closes beyond confirmed swing level
Recognizes CHoCH when structure break occurs against current trend
Step 3: Confluence Calculation
Awards +1 for HTF bias alignment
Awards +1 for active killzone timing
Awards +1 for optimal zone positioning (discount for longs, premium for shorts)
Awards +1 for price at unmitigated POI
Awards +1 for recent liquidity sweep in trade direction
Awards +1 for recent supportive structure break
Step 4: Signal Generation
Compares total score against user-defined minimum threshold
Requires candle confirmation (bullish close for longs, bearish close for shorts)
Applies 10-bar spacing filter to prevent signal clustering
💡 Note:
This indicator is designed for traders already familiar with Smart Money Concepts. While it automates detection and scoring, understanding why each factor matters will significantly improve your ability to filter signals and manage trades effectively. Use the minimum confluence setting to match your risk tolerance, higher values mean fewer but higher-quality signals.
Enhanced MTF Bias Table by Odegos# Enhanced MTF Bias Table - Publication Description
## Short Description (for TradingView listing)
Multi-timeframe bias indicator combining Market Structure Shifts (MSS) with EMA analysis. Displays real-time bias across 7 timeframes (5m-Weekly) with distance metrics and volatility measurements. Perfect for identifying trend alignment and potential reversal points.
---
## Full Description
### Overview
The **Enhanced MTF Bias Table** is a comprehensive multi-timeframe analysis tool designed to help traders quickly identify market bias across different time horizons. By combining Market Structure Shift (MSS) detection with Exponential Moving Average (EMA) analysis, this indicator provides a clear, color-coded view of market sentiment from short-term (5-minute) to long-term (weekly) timeframes.
### What This Indicator Does
**Core Functionality:**
- **Multi-Timeframe Analysis**: Simultaneously monitors 7 different timeframes (5m, 15m, 30m, 1h, 4h, Daily, Weekly)
- **Market Structure Detection**: Identifies when price breaks previous swing highs/lows, indicating potential trend changes
- **EMA-Based Bias**: Combines market structure with price distance from a customizable EMA to determine bias strength
- **Visual Market Structure Shifts**: Draws horizontal lines on the chart when significant market structure shifts occur
- **Real-Time Metrics**: Displays distance from EMA and ATR (volatility) for each timeframe
### How It Works
**Bias Calculation Logic:**
The indicator uses a sophisticated two-factor approach to determine market bias:
1. **Market Structure Analysis**:
- Tracks swing highs and lows using pivot points
- Identifies when price breaks above previous highs (bullish structure) or below previous lows (bearish structure)
- Uses a customizable lookback period to filter noise
2. **EMA Distance Analysis**:
- Measures how far price is from the selected EMA
- Strong bias requires BOTH structure break AND significant distance from EMA
- Neutral zone prevents false signals when price consolidates near the EMA
**Bias Categories:**
- **Strong ↑** (Dark Green): Bullish market structure + price above EMA threshold
- **Weak ↑** (Light Green): Bullish structure OR price moderately above EMA
- **Neutral** (Orange): Price within neutral zone around EMA
- **Weak ↓** (Light Red): Bearish structure OR price moderately below EMA
- **Strong ↓** (Dark Red): Bearish market structure + price below EMA threshold
### Key Features
**📊 Customizable Table Display:**
- Two table styles: Compact (minimal) or Full (detailed with labels)
- 9 position options to fit any chart layout
- Toggle distance from EMA and ATR displays
- Shows current symbol, timeframe, and date
**📈 Flexible Indicator Settings:**
- Adjustable EMA length (default: 50)
- Customizable MSS lookback period (5-50 bars)
- Breakout threshold adjustment for different instruments
- Neutral zone configuration to reduce noise
**📍 Visual Market Structure Shifts:**
- Draws horizontal lines at significant structure breaks
- Customizable colors for bullish/bearish MSS
- Optional text labels ("MSS") for easy identification
- Adjustable line width and style (solid, dashed, dotted)
**📉 EMA Overlay:**
- Optional EMA display on chart
- Full customization: color, width, line style
- Helps visualize the reference point for bias calculations
**🎨 Full Color Customization:**
- Independent color controls for all bias levels
- Customize header and table appearance
- Matches any chart theme or preference
### Best Use Cases
**1. Trend Alignment:**
Use the MTF table to identify when multiple timeframes align in the same direction. When 5-6 or more timeframes show the same bias, it indicates strong directional momentum.
**2. Divergence Detection:**
Look for disagreements between timeframes. For example, if higher timeframes (Daily/Weekly) show bearish bias while lower timeframes (5m/15m) show bullish bias, it may indicate a counter-trend bounce or potential reversal setup.
**3. Entry Timing:**
Use higher timeframe bias for direction and lower timeframe bias for entry timing. Enter trades when your trading timeframe aligns with higher timeframe bias.
**4. Risk Management:**
When lower timeframes show opposite bias to higher timeframes, it suggests trading against the major trend—requiring tighter stops and smaller positions.
**5. Market Structure Confirmation:**
The MSS lines help identify key levels where market structure changed, useful for:
- Stop loss placement (below/above MSS levels)
- Target setting (previous structure points)
- Breakout confirmation
### Recommended Settings by Instrument
**Index Futures:**
- **ES (S&P 500)**: Breakout Threshold: 0.15%, Neutral Zone: 0.15%
- **NQ (Nasdaq)**: Breakout Threshold: 0.25%, Neutral Zone: 0.20%
- **YM (Dow Jones)**: Breakout Threshold: 0.20%, Neutral Zone: 0.20%
**Forex Pairs:**
- **Major Pairs**: Breakout Threshold: 0.10%, Neutral Zone: 0.10%
- **Volatile Pairs**: Breakout Threshold: 0.20%, Neutral Zone: 0.15%
**Cryptocurrencies:**
- Breakout Threshold: 0.30-0.50%, Neutral Zone: 0.25-0.40%
- Higher volatility requires larger thresholds
### Understanding the Metrics
**Distance from EMA (%):**
- Positive values = Price above EMA (bullish territory)
- Negative values = Price below EMA (bearish territory)
- Larger absolute values = Stronger deviation from mean
- Useful for identifying overextended moves
**ATR (%):**
- Measures current volatility as percentage of price
- Higher values = More volatile conditions
- Helps adjust position sizing and stop distances
- Compare across timeframes to see where volatility concentrates
### Tips for Optimal Use
1. **Start with higher timeframes**: Check Daily and Weekly bias first to understand the bigger picture
2. **Use the 50 EMA default**: It's widely used and provides reliable support/resistance
3. **Adjust MSS lookback for your style**: Lower values (5-7) for day trading, higher values (15-25) for swing trading
4. **Watch for neutral zones**: Orange/neutral readings often precede significant moves
5. **Combine with price action**: Use MSS lines as reference points for entries and exits
6. **Don't ignore weak signals**: "Weak" bias often precedes strong moves as structure builds
### What Makes This Different
Unlike simple moving average indicators, this script:
- Combines TWO confirmation factors (structure + distance) for more reliable signals
- Provides context across multiple timeframes simultaneously
- Visually marks important market structure changes on your chart
- Offers both compact and detailed display modes
- Includes volatility measurement to gauge market conditions
### Technical Notes
- Uses `request.security()` to fetch data from multiple timeframes
- Implements `pivothigh()` and `pivotlow()` for swing detection
- All calculations use `lookahead=barmerge.lookahead_off` to prevent repainting
- MSS lines drawn in real-time as structure breaks occur
- Optimized for performance with minimal script resources
### Disclaimer
This indicator is a tool for analysis and does not provide trading signals or financial advice. Always:
- Use proper risk management
- Combine with other forms of analysis
- Test thoroughly in a demo environment
- Understand that past performance doesn't guarantee future results
- Consider market conditions and fundamental factors
---
## Tags (for TradingView)
multi-timeframe, market-structure, bias, trend, EMA, momentum, support-resistance, price-action, volatility, ATR, swing-trading, day-trading
## Category
Trend Analysis / Multi-Timeframe Analysis
---
## Quick Start Guide
**For Day Traders:**
1. Add indicator to your chart
2. Focus on 5m, 15m, 30m, and 1h timeframes
3. Look for alignment across these timeframes
4. Use MSS lines as entry/exit reference points
**For Swing Traders:**
1. Add indicator to your chart
2. Focus on 4h, Daily, and Weekly timeframes
3. Wait for 2-3 timeframe alignment
4. Use lower timeframes only for entry timing
**For Position Traders:**
1. Add indicator to your chart
2. Focus on Daily and Weekly timeframes
3. Ignore short-term noise
4. Enter when both show same strong bias
Breaker Blocks Finder | Gold | ProjectSyndicateProjectSyndicate Breaker Blocks Finder
📊 Overview
The ProjectSyndicate Breaker Blocks Finder (PS BB Finder) is a professional-grade Pine Script indicator designed to detect and display Bullish and Bearish Breaker Blocks based on Smart Money Concepts (SMC) methodology. This indicator is specifically optimized for XAUUSD (Gold) trading but works reliably across all symbols and timeframes.
Key Features
✅ Non-Repainting: Breaker blocks never change position after formation
✅ Multi-Timeframe Support: Optimized for M5, M10, M15, M20, M30, and H1
✅ Highly Customizable: 10+ user-configurable settings
✅ Visual Clarity: Color-coded boxes and labels for easy identification
✅ Performance Optimized: Handles 1000+ candles without lag
✅ Cross-Symbol Compatible: Works on Forex, Crypto, Stocks, Indices, and Commodities
✅ Displacement Detection: Uses ATR-based displacement to filter false signals
🎯 What are Breaker Blocks?
A Breaker Block is a failed order block that becomes a new support or resistance zone after being invalidated by price. It represents a market structure shift where institutional traders (smart money) have flipped their position.
Bullish Breaker Block
A Bullish Breaker Block forms when:
1 A bearish order block (resistance zone) exists
2 Price breaks ABOVE this zone with strong displacement
3 The former resistance zone now becomes SUPPORT
4 Price may retest this zone before continuing higher
Visual: Green box with "BB ▲" label
Bearish Breaker Block
A Bearish Breaker Block forms when:
5 A bullish order block (support zone) exists
6 Price breaks BELOW this zone with strong displacement
7 The former support zone now becomes RESISTANCE
8 Price may retest this zone before continuing lower
Visual: Red box with "BB ▼" label
⚙️ Default Settings
Setting Default Range Description
Lookback Period 1000 100-5000 Number of historical candles to analyze
Max Breaker Blocks 5 1-50 Maximum number of breaker blocks to display
Swing Detection Length 10 2-20 Bars on each side to confirm swing high/low. Higher = more significant swings
Use Displacement Filter true true/false Enable to filter breaker blocks by displacement size
Displacement Multiplier 2.0 0.5-5.0 Minimum move size as multiple of ATR. Higher = stricter detection
Invalidation Method Close Close/Wick Close = Conservative (candle must close beyond zone)Wick = Aggressive (wick touch is enough)
📈 Recommended Timeframes & Settings
This indicator is optimized for the following timeframes. Use these settings as a starting point.
Lower Timeframes (M5, M10, M15, M20)
These settings are designed to capture faster price movements and are the default settings for the indicator.
Setting Recommended Value
Lookback Period 1000
Max Breaker Blocks 5
Swing Detection Length 10
Use Displacement Filter true
Displacement Multiplier 2.0
Invalidation Method Close
Higher Timeframes (M30, H1)
For these timeframes, a less strict displacement filter is recommended to capture more significant, but less frequent, breaker blocks.
Setting Recommended Value
Lookback Period 1000
Max Breaker Blocks 5
Swing Detection Length 10
Use Displacement Filter true
Displacement Multiplier 1.0
Invalidation Method Close
🎓 How to Use
Step 1: Identify Breaker Blocks
Once the indicator is loaded, breaker blocks will automatically appear on your chart:
• Green boxes = Bullish breaker blocks (former resistance, now support)
• Red boxes = Bearish breaker blocks (former support, now resistance)
Step 2: Wait for Retest
The most reliable trading opportunities occur when price retests the breaker block zone:
• For bullish breaker blocks, wait for price to come back down to the green zone
• For bearish breaker blocks, wait for price to come back up to the red zone
Step 3: Look for Confluence
Combine breaker blocks with other SMC concepts for higher probability setups:
• Fair Value Gaps (FVG) within the breaker block zone
• Liquidity grabs before the retest
• Break of Structure (BoS) or Change of Character (ChoCH) confirmation
Step 4: Enter the Trade
Bullish Setup:
• Entry: At or near the bullish breaker block zone
• Stop Loss: Below the breaker block
• Take Profit: Previous swing high or higher
Bearish Setup:
• Entry: At or near the bearish breaker block zone
• Stop Loss: Above the breaker block
• Take Profit: Previous swing low or lower
🛡️ Non-Repainting Guarantee
This indicator is 100% non-repainting, meaning:
✅ Breaker blocks never change position after formation
✅ Historical breaker blocks remain in the exact same location indefinitely
✅ Backtesting results are reliable and consistent
🐛 Troubleshooting
Issue: No Breaker Blocks Appearing
Solutions:
• Ensure "Use Displacement Filter" is enabled.
• On M30/H1, try lowering the "Displacement Multiplier" to 1.0.
• Scroll back in history; blocks may not be present on the most recent bars.
Issue: Too Many Breaker Blocks
Solutions:
• Increase "Displacement Multiplier" to 2.5 or 3.0.
• Increase "Swing Detection Length" to 12-15.
• Decrease "Max Breaker Blocks" to 3-4.
Custom Price Offsets v6.1For use on ES, default 3, 6, 9, 13, and 19 point targets. Add indicator and click the price level that you want to use in order to measure the targets. Delete and re-apply to change set point.
