เริ่มกันเลย

SMT

SMT Divergence [MTF]## SMT Divergence **Smart Money Technique (SMT) Divergence** detects structural price divergences between two correlated assets — most commonly NQ (Nasdaq) and ES (S&P 500) futures. When one instrument sweeps a liquidity level (makes a new high or low) while the other fails to confirm, it signals a potential reversal driven by institutional order flow. This indicator is built for serious intraday and swing traders who apply ICT or Smart Money concepts in their analysis. --- ### How it works A **Bullish SMT** is detected when: - The main asset prints a **lower low** compared to its previous swing low - The comparison asset simultaneously prints a **higher low** - → NQ swept liquidity, ES did not confirm → reversal to the upside expected A **Bearish SMT** is detected when: - The main asset prints a **higher high** compared to its previous swing high - The comparison asset simultaneously prints a **lower high** - → NQ swept liquidity, ES did not confirm → reversal to the downside expected Pivots are confirmed using a **Williams Fractal** approach: N bars on both sides must be lower (for highs) or higher (for lows) before a pivot is accepted. This avoids premature signals on unconfirmed wicks. --- ### Key features **Multi-Timeframe (MTF)** Configure up to 3 higher timeframes independently. When you are on a 5-minute chart, 1H and 4H divergences are projected directly onto your chart — correctly anchored to the exact price bars where the pivots occurred. Each timeframe has its own color scheme (dark → medium → light) and line width so you can instantly distinguish timeframe importance at a glance. **Two Comparison Assets** Compare the chart instrument against up to two correlated assets simultaneously (default: ES and NQ). Each asset can be enabled or disabled independently. **Pivot Quality Filters** - *Candle Direction Validation*: optionally require that a pivot high was formed on a bullish candle and a pivot low on a bearish candle — filtering out weak wicks - *Minimum Distance Filter*: only accept divergences where the swing size exceeds a configurable threshold, either as a fixed number of points or as a multiple of ATR(14) **Invalidation Detection** Once price closes beyond the sweep level (below a bullish SMT low, or above a bearish SMT high), the signal is automatically marked as invalidated. Choose between three modes: - *Dashed*: lines become dashed and faded - *Hide*: lines and labels are removed entirely - *Recolor*: lines are repainted in a configurable color (default: gray) **Clean visual output** - Solid main-asset line + faded comparison-asset line per signal - Configurable line label at the midpoint (e.g. "1H SMT", "4H SMT") - Optional action label with bias, entry suggestion, and stop-loss level - No repainting: all pivots are confirmed only on closed bars using `lookahead_off` --- ### Recommended settings | Timeframe | Pivot Lookback | |-----------|---------------| | 5 min | 2–3 | | 15 min | 3 | | 1H | 3–4 | Apply the indicator to your **NQ chart** with ES as Asset A. For ES traders, apply to the ES chart with NQ as Asset A. --- ### Notes - This indicator does **not** repaint. Signals appear only after both pivot bars are fully confirmed. - The HTF pivot lines are anchored to the exact chart bar where the high or low occurred, ensuring precise visual alignment across timeframes. - Built for NQ/ES futures but works with any pair of correlated instruments (e.g. DJI/SPX, BTC/ETH).
อินดิเคเตอร์ Pine Script®
โดย osterhansi_
SMT-Fill [Oracle]WHAT THIS INDICATOR DOES SMT-Fill is a correlation-based fair value gap analysis tool that detects when correlated assets disagree on how they interact with their own imbalances. It identifies FVGs that form simultaneously across multiple correlated assets, then tracks whether each asset trades back into its respective gap — and flags when one asset fills its gap while the other does not. A standard FVG tells you there is an imbalance. An SMT-Fill tells you there is an imbalance where correlated assets are disagreeing on whether it gets respected — a crack in correlation at the imbalance level, which increases the probability of a reaction. This is an analysis and narrative tool. It does not generate buy or sell signals. THE CONCEPTS — WHAT EACH ONE IS AND HOW IT IS CALCULATED Fair Value Gaps (FVGs) A fair value gap is a 3-bar price imbalance where the candle bodies moved so aggressively that a gap was left behind. The indicator detects these using standard FVG logic: Bullish FVG — Bar 1's low is above bar 3's high. The gap between these two levels represents an area where price moved up without being fully traded, leaving an imbalance that price may return to fill. Bearish FVG — Bar 3's low is above bar 1's high. The gap represents a downward imbalance. The indicator does not just detect FVGs on your chart — it simultaneously checks whether the same FVG pattern exists on each of the other assets in your triad at the exact same time, using request.security calls. For each asset where a concurrent FVG exists, it stores that asset's own gap boundaries (high, low, and midpoint) independently. This means the indicator is tracking up to four versions of the same gap: your chart asset's FVG boundaries and each correlated asset's FVG boundaries, all formed on the same 3-bar window but at each asset's own price levels. SMT-Fill Divergence Detection This is the core concept. After an FVG forms across multiple assets, the indicator tracks whether price on each asset trades back into its respective gap. An SMT-Fill divergence occurs when one asset trades into its gap while a correlated asset does not trade into its corresponding gap — the assets disagree on whether the imbalance gets filled. The indicator monitors three levels within each gap: High — The top boundary of the FVG. Has price touched back into the gap at all? Midpoint (50%) — The equilibrium of the FVG. Has price traded through the halfway point? Low — The bottom boundary of the FVG. Has price completely filled the gap? For each level, the indicator maintains a "traded" flag for every asset. On every bar, it checks whether each asset's price has reached that level in its own FVG. A divergence is detected when your chart asset's traded flag differs from a correlated asset's traded flag at any level — meaning one has interacted with the gap at that level while the other has not. This produces three variants of SMT-Fill, each representing a different degree of divergence: Variant 1 — Touch divergence. One asset trades back into the gap (touching the high of the FVG), while the correlated asset fails to trade back into its gap at all. Variant 2 — Midpoint divergence. One asset trades below 50% of its gap, while the correlated asset fails to reach the 50% level of its gap. Variant 3 — Full fill divergence. One asset completely fills its gap (price reaches the low/high boundary), while the correlated asset fails to completely fill its corresponding gap. The indicator prioritises the most significant divergence level when drawing the SMT-Fill line. For bullish gaps, it checks the high level first (has any asset touched the gap while another hasn't), then midpoint, then low. For bearish gaps, it checks low first, then midpoint, then high. Gap Lifecycle and Cleanup Each tracked gap has a defined lifecycle: Creation — A 3-bar FVG is detected on your chart, and the same FVG pattern exists on at least one other asset in the triad at the same time. Active tracking — The indicator monitors whether each asset's price interacts with its own version of the gap at the high, midpoint, and low levels. Divergence display — When the traded flags disagree between assets at any level, the gap is drawn as a colored box with an optional SMT divergence line at the diverging level. Closure — When price closes completely through the gap (close below the low for bullish, close above the high for bearish), the gap is automatically deleted from the chart. Gaps where no divergence exists between assets are hidden by default — the indicator only shows FVGs where a crack in correlation has occurred within the imbalance. SMT-Fill Divergence Line When a divergence is detected, an optional horizontal line is drawn at the specific level where the disagreement occurs (high, midpoint, or low of the gap). This line marks the exact price level where one asset has interacted with the gap but the other has not — the precise point of the crack in correlation within the imbalance. The line extends as long as any asset is still interacting with the gap, plus a configurable extension buffer. HOW THE CONCEPTS WORK TOGETHER SMT-Fill is not simply an FVG detector with extra assets overlaid. The concepts form a specific analytical sequence: Concurrent FVG formation establishes the setup. A fair value gap must form on your chart asset and on at least one correlated asset at the exact same time. This is the prerequisite — it means both assets experienced the same imbalance event simultaneously, establishing a shared reference point. Independent fill tracking reveals disagreement. After the gap forms, each asset's price moves independently. The indicator tracks whether each asset returns to its own gap boundaries. When one fills while the other holds, it reveals that the market is not treating the imbalance the same way across correlated assets — a crack in correlation specifically within the imbalance itself. The divergence level identifies the price point. The SMT-Fill line marks exactly where the disagreement is occurring — whether at the gap entry (high), equilibrium (midpoint), or full fill (low). This gives you a specific price level to work with, not just a directional bias. Gap lifecycle provides context. Gaps that are fully closed are automatically removed. Only gaps with active divergences are displayed. This keeps the chart clean and focused on the information that matters — where correlated assets are currently disagreeing on imbalance interaction. HOW TO USE IT For HTF Bias: SMT-Fills on higher timeframes can frame lower timeframe trade ideas. For example, if you expect a bullish weekly candle and see price manipulate down into a daily FVG forming an SMT-Fill, you can assume that manipulation is likely the manipulation for the week — giving you a directional bias and allowing you to frame LTF entries accordingly. As an Entry Model: SMT-Fill can be combined with other Quarterly Theory concepts to build confluence. For example: SSMT forms, then the first presented gap is an SMT-Fill — higher probability entry A PSP forms, then the first presented gap is an SMT-Fill — confirmed reversal with imbalance divergence Any ICT entry model that involves an FVG can use SMT-Fill to increase the setup probability by confirming the gap is backed by a correlation crack Step by step: Add the indicator to your chart. It will automatically detect your asset triad and begin scanning for concurrent FVGs. When an FVG forms on your chart and on at least one correlated asset simultaneously, the indicator begins tracking fill levels on all assets. Once one asset trades into its gap while another does not, a colored box appears showing the SMT-Fill gap with a label indicating which asset is diverging. The SMT-Fill divergence line marks the exact level where the disagreement is occurring. Gaps are automatically removed when fully closed, keeping your chart clean. WHY THIS IS THIS INDICATOR WORTH USING? Without this indicator, identifying an SMT-Fill requires a trader to: Watch three charts simultaneously and mentally note when FVGs form at the same time across all of them Track the exact high, midpoint, and low of each gap on each asset independently Monitor in real time whether each asset trades back into its own gap at each of these three levels Compare the fill status across assets to determine if a divergence exists Remember which gaps have been fully closed and which are still active This is practically impossible to do manually in real time across three assets and multiple active gaps. The indicator automates the entire process — concurrent FVG detection, independent multi-level fill tracking across all triad members, divergence flagging, and automatic lifecycle management — into a single overlay. The SMT-Fill concept itself — tracking whether correlated assets agree or disagree on how they interact with simultaneously-formed imbalances — is an entirely original implementation. No other TradingView indicator detects concurrent FVGs across multiple assets, independently tracks fill levels at three price points per asset, and flags the divergence when assets disagree. This cannot be replicated by combining existing public FVG indicators because they only track a single asset and have no concept of cross-asset fill comparison. AUTO TRIAD The indicator automatically assigns the correct correlated triad based on your chart ticker: Index Futures: NQ / ES / YM (+ micro variants MNQ / MES / MYM) FX Indices: NAS100 / SPX500 / US30 Metals (spot): XAUUSD / XAGUSD / Copper Metals (futures): GC / SI / HG Forex: EURUSD / GBPUSD / DXY Currency Futures: 6E / 6B / DXY Energy: CL / RB / HO Bonds: ZF / ZB / TN Crypto (spot): BTCUSD / ETHUSD / XRPUSD via Kraken For unsupported tickers, manual configuration is available. SETTINGS OVERVIEW Asset Selection — Auto triad toggle, manual ticker inputs for three assets General Settings — Maximum gaps tracked, box extension length Gap Display — Bullish/bearish toggles, gap colors, border display and width SMT-F Line — Divergence line toggle, color, style, width Labels and Text — Asset label toggle, text size, text color, label position Filtering — Active-only mode (only show gaps while price is interacting) Watermark — Position, size, custom phrase INDICATOR SETTINGS/FILTERS Here is an inside look of how the SMT-Fill looks: DISCLAIMER This indicator is for educational and informational purposes only. It does not constitute financial advice. Trading involves substantial risk of loss. Always use proper risk management and conduct your own analysis. CREDITS Developed by Danielliuks (z3nius) and bucko. Conceptual framework based on ICT (Michael Huddleston) and Quarterly Theory as taught by TraderDaye. Open Sourced For all. Enjoy.
อินดิเคเตอร์ Pine Script®
โดย buckotrades
2
Ultimate FVG/NWOG By FreedomByChartsUltimate FVG/NWOG By FreedomByCharts A clean, no-bloat FVG and NWOG indicator built around how I actually trade: chart timeframe + three independent higher timeframes + the New Week Opening Gap, all in one global colour scheme with sensible defaults and granular per-source control. Why this one Most FVG indicators on TV fall into one of two camps. Either they're stripped down to the bare chart-timeframe pattern with a single fill colour and a hardcoded mitigation rule, or they're bloated with theme presets, IPDA modes, half-finished features and ten settings groups you'll never use. This one is built the other way round: deep where it matters (mitigation logic, NWOG accuracy, display control), and stripped of everything that doesn't earn its place on the chart. What's actually different: Four mitigation modes, not one. Wick Filled (full), Body Filled (full), Wick 50%, Body 50%. Pick what matches your model — strict body close beyond the far side, or a partial wick into the midpoint, or anything between. Independent box and line visibility per source. Box on, lines off. Lines on, box off. Top + bottom only, no middle. Mid line dotted, top and bottom solid. Whatever you want — five sources, each independent. Mitigated FVGs become iFVGs. When an FVG gets mitigated its label flips from e.g. `1H` to `1H iFVG`, marking the zone as an inverted FVG — the same level can now act in the opposite direction. NWOG labels stay as `NWOG` since the inversion concept doesn't apply. Mitigated zones can drop their lines automatically. Per-source toggle: keep the grey box for context, lose the line clutter. Active zones stay fully drawn. Three HTFs at once, plus chart TF, plus NWOG. Run 1H, 4H, 1D simultaneously while the chart-TF FVGs print on whatever you're looking at. Each fully configurable. No request.security guesswork — the HTF tracking is explicit and aligned to the chart bars where each HTF period's high and low actually occurred. NWOG done properly, including holiday weeks. The NWOG anchors to the close of the last 1H bar before the weekend (Friday on a normal week, Thursday on Easter / Good Friday week) and the open of Sunday's first 1H bar. No stale Friday-only state, no wrong-priced boxes anchored at the wrong bar after holiday closes. Single global colour scheme. One bullish colour, one bearish colour, one mitigated grey. Applied uniformly across every source for a clean, professional look. NWOG can override its own bull/bear colours if you want it to stand out. No display caps you have to work around. Set the unfilled count and mitigated count per source to whatever you actually want to see. Old zones get pruned automatically as new ones form. What it draws Chart FVGs — current timeframe, both bullish and bearish. HTF1, HTF2, HTF3 — three configurable higher timeframes (defaults: 1H, 4H, 1D), all rendered on the current chart. NWOG — the body gap between the close of the last 1H trading bar before the weekend and the open of Sunday's first 1H bar. For each zone you get an optional coloured box (transparency adjustable), an optional top line, mid line, bot line (each with independent show/hide and Solid/Dashed/Dotted style), and an optional label showing the timeframe (auto-formatted as "1H", "4H", "1D", "NWOG", etc). When a zone is mitigated, the box recolours to grey, the lines either go grey or hide entirely depending on the per-source toggle, and the label flips to show iFVG status (e.g. `1H` becomes `1H iFVG` — NWOGs keep their `NWOG` label). Mitigated zones stay visible for as many slots as you allow, then get pruned. Mitigation methods explained For a bullish FVG (zone below price), the chosen method tests whether price has come back down into the zone: Wick Filled (full) — bar's low has reached the bottom of the zone. Default. Body Filled (full) — bar's close has reached the bottom of the zone. Wick 50% — bar's low has reached the midpoint. Body 50% — bar's close has reached the midpoint. Bearish zones (above price) test the opposite direction. Mitigation triggers an alert if you've enabled it for that source. Alerts Two alert flags per source: entry (price first touches the zone) and mitigation (price meets the mitigation criterion). Alert text identifies the source timeframe, direction (bull or bear) and the price. Settings, top to bottom Appearance — bull / bear / mitigated colours, box transparency, mitigated box transparency, line width, right-edge extension (default 0 = right edge sits at the current bar; raise it to extend further right), label text colour. Mitigation — single global mitigation method dropdown. Chart — enable, box / line visibility, line styles, unfilled and mitigated counts, mitigated-lines toggle, label settings, alerts. HTF 1, HTF 2, HTF 3 — same controls as Chart plus a timeframe input. NWOG — same controls as the others, plus optional NWOG-specific bull/bear colour overrides. Notes on usage For NWOG live detection use a 1H or smaller intraday chart. On 4H+ charts the bar boundaries don't land on the 18:00 NY moment cleanly so new NWOGs won't form. HTF FVGs appear on the chart at the bar where their HTF period closed, anchored back to the chart bars where the relevant HTF candle highs and lows occurred — this gives a clean "stepped" visual at the zone's left edge that shows how it formed. The right edge of every zone tracks the current bar in real time. Set "Extend right beyond current bar" higher if you prefer a fixed runway. TradingView caps total drawn objects at 500 lines / 500 boxes / 500 labels. With three lines per zone enabled across many sources at high display caps, you can hit those limits — drop the mid line first (it's off by default for that reason) and you double your headroom. Built specifically for the way I trade GC futures on the 1H. Sharing because I haven't seen another FVG indicator that handles all three of these together: holiday-week NWOGs, four mitigation modes, and independent box/line control per source. Feedback welcome.
อินดิเคเตอร์ Pine Script®
โดย FreedomByCharts
Minicharts Multi Market [Herman]Minicharts Multi Market Minicharts Multi Market is a multi-asset visualization tool designed to display several different markets directly on a single chart using compact embedded mini charts. Instead of switching between multiple tabs and layouts, this script allows traders to monitor intermarket behavior, relative strength, SMT relationships, and higher timeframe structure from one workspace. The indicator is intended as a visual decision-support tool only and does not generate buy or sell signals. Purpose The main goal of this script is to improve chart workflow and market awareness by allowing users to: • Monitor multiple correlated assets at the same time • Compare futures markets such as NQ, ES, YM, RTY, CL, GC and others • Observe relative strength and weakness across markets • Identify potential SMT divergences between correlated instruments • Keep higher timeframe structure visible while executing on lower timeframes • Reduce the need to constantly switch charts during active trading sessions This helps traders maintain better context and avoid missing important intermarket information. How It Works The script uses request.security() to retrieve OHLC data from multiple user-selected symbols and reconstructs them as compact mini charts displayed on the right side of the main chart. Each mini chart functions independently and can display: • Custom symbol • Custom timeframe • Optional EMA • Optional VWAP • Optional SMT detection • Optional HTF Fair Value Gaps (FVG / iFVG) The indicator does not use repainting logic for visualization purposes and is designed for structural reference and contextual analysis. Main Features 1. Multi-Asset Minicharts Display up to 6 different assets simultaneously. Examples: • NQ • ES • YM • RTY • CL • GC • SI • Forex pairs • Indices • Any TradingView-supported symbol Each chart can use its own symbol and its own timeframe. This makes the script useful for: • Index traders • Futures traders • SMT traders • Intermarket analysis • Session-based traders • Higher timeframe structure alignment 2. Automatic SMT Detection The script includes optional SMT (Smart Money Technique) divergence visualization. It automatically detects correlated comparison assets: Examples: • NQ ↔ ES • ES ↔ NQ • YM ↔ ES • RTY ↔ ES • GC ↔ SI • CL ↔ RB When pivot highs or lows diverge between assets, the script highlights these areas visually. This feature is designed to assist traders who use SMT as confirmation, not as a standalone entry signal. 3. EMA Overlay Each mini chart can optionally display EMA. Settings include: • Enable / disable EMA globally • Enable / disable EMA per mini chart • Custom EMA period • Custom EMA color This helps users quickly identify trend alignment across markets. 4. VWAP Overlay Each mini chart can optionally display VWAP. Settings include: • Enable / disable VWAP globally • Enable / disable VWAP per mini chart • Custom VWAP color This allows users to monitor mean reversion and institutional reference pricing across multiple instruments. 5. HTF Fair Value Gaps (FVG) Optional HTF Fair Value Gap visualization is included. The script detects: • Bullish FVG • Bearish FVG • Inverted FVG (iFVG) Users can choose: • Extended mode • Next Bar Only mode This helps provide additional structural context on higher timeframe inefficiencies. Settings Overview Minicharts Assets Setup For each mini chart: • Enable / disable chart • Select symbol • Select timeframe • Enable / disable SMT • Enable / disable EMA • Enable / disable VWAP Each of the 6 mini charts can be customized independently. EMA Configuration • Show EMA • EMA period • EMA color VWAP Configuration • Show VWAP • VWAP color HTF FVG Configuration • Show FVG • Extension mode • Bullish FVG color • Bearish FVG color • Inverted FVG color Style & Layout • Pivot lookback for SMT • SMT colors • Candle colors • Number of bars shown • Bar spacing • Background frames • Right offset • Column spacing • Chart height • Row spacing • Asset / timeframe labels These controls allow users to fully adapt the layout to their chart style. Important Notes This script is designed for visualization purposes only It does not generate trading signals, alerts, or recommendations All calculations are based on historical price data The tool is intended to support chart analysis, not replace independent decision-making
อินดิเคเตอร์ Pine Script®
โดย helmans13
8
cracks in correlation (smt)introducing what (in my opinion) might be the best open-source smt divergence indicator yet! as you may know, an SMT divergence forms when 2 correlated pairs' structure diverges (i.e. NQ makes a higher high and ES makes a lower high). when this happens, smart money traders take advantage of the "crack in correlation" and enter positions looking for the assets to converge again. with this indicator, you will NEVER miss an smt again! allow me to bore you with the technicals for a bit. while most smt indicators only compare 2 pivots, this one (using the amazing ZigZag library by Trendoscope), allows us to compare up to 128 different pivots at once, ensuring that every high is compared with every other high. this setting is controlled using the "memory buffer" counter inside the inputs of the indicator. raising this setting will make the indicator take more time to load, but will also show you more potential smts. using this zigzag, we're able to check whether the corresponding asset's structure is the same as the current one. all of the other settings should be self-explanatory, but should you have any questions, you can reach out to me in the comments below. as this indicator is open-source, feel free to reuse it as you wish, but if you are re-using significant portions of it, please credit me. it would mean a lot to me :> thank you for using my indicator. happy trading!
อินดิเคเตอร์ Pine Script®
โดย k4sual
1
SMT Divergence | Multi-Index Liquidity ComparisonSMT Divergence Map | Multi-Index Liquidity Comparison Description: Overview This indicator tracks structural divergence between correlated index futures by comparing relative highs and lows across multiple markets. It is designed as a market-structure mapping tool, not as a standalone trade signal. The goal is to make intermarket disagreement visible so the user can judge whether one market is confirming or failing to confirm the movement of another. What the script plots The script compares selected symbols such as NQ, ES, and YM and highlights divergence when one market takes a corresponding high or low while another does not. It can monitor multiple timeframes and can also project selected higher-timeframe reference levels onto the active chart so the user can evaluate divergence in context. How the logic works The script reads highs and lows from 7 lookback bars of the selected symbols over the chosen comparison windows to the current market price. A bearish-style divergence is identified when one market trades above a prior reference high while another correlated market fails to do the same. A bullish-style divergence is identified when one market trades below a prior reference low while another correlated market fails to confirm that low. The script then plots the relevant divergence markers and optional reference lines on the chart. Inputs and customization Users can choose which symbols to compare, which timeframes to evaluate, which divergence types to display, and whether to show supporting structures such as prior highs/lows, session references, daily references, or higher-timeframe range levels. Visual controls allow the user to adjust labels, line styles, colors, table size & transparency customization and display density. How to use it This tool is best used as a structural context layer. It helps identify areas where correlated markets stop agreeing, which may matter near liquidity sweeps, session extremes, or higher-timeframe reference levels. The script does not place orders and does not guarantee reversal or continuation. It simply visualizes divergence so the trader can combine it with their own execution framework. Originality / why this script exists This publication consolidates multiple SMT comparison functions into one configurable tool so users do not need several overlapping variants. The purpose is not to merge indicators for the sake of a mashup, but to provide one organized framework for viewing intermarket divergence, session references, and higher-timeframe structure in a single workflow. Limitations Divergence is contextual and does not automatically imply a successful trade. Different data feeds, symbol mappings, session settings, and timeframes can change what is displayed. Users should verify the symbol configuration and session definitions before relying on the output. Note This is a charting and analysis tool. It does not make performance claims, does not predict future results, and should be used as one component of a broader decision process.
อินดิเคเตอร์ Pine Script®
โดย Selenophile_Associates_GP
Liquidity sweep divergence (SMT) This script implements a refined version of SMT (Smart Money Technique) divergence, focused specifically on liquidity sweeps between correlated assets rather than simple structural divergence. Use it on one market: FOREX: EURUSD + DXY (or GBPUSD + DXY) CRYPTO: BTC+ETH (BTC + TOTAL3, ETH + TOTAL3) INDICES: ES + NQ COMMODITIVES: XAU + XAG (GOLD+SILVER) Unlike traditional SMT indicators that rely on comparing consecutive swing highs/lows (HH/LL logic), this script detects true liquidity events, where one asset takes liquidity (sweeps a previous swing) while the other fails to do so. 🔍 Core Concept SMT divergence in this script is defined as: Bearish SMT The main chart sweeps a previous swing high (liquidity taken) The second asset fails to sweep its corresponding swing high Bullish SMT The main chart sweeps a previous swing low The second asset fails to do the same This reflects asymmetry in liquidity behavior, often interpreted as a sign of weakening trend continuation and potential reversal. ⚙️ How It Works The script uses: 1. Pivot-based swing detection Uses confirmed pivots (ta.pivothigh / ta.pivotlow) Eliminates noise and repaint issues from naive fractal logic 2. Cross-asset synchronization Swings between assets are matched using a configurable bar offset tolerance Ensures meaningful comparison between structurally aligned points 3. Liquidity sweep detection Detects when price: Breaks a previous swing level (high/low) Optionally closes back inside (ICT-style wick sweep) 4. Signal filtering To reduce false SMT signals, the script includes: ATR-based minimum move filter Optional wick confirmation (true liquidity grab) No multi-swing brute-force scanning (only relevant structure is used) 🎯 What Makes This Script Unique Focuses on liquidity sweeps, not just HH/LL divergence Avoids common SMT noise from weak structural comparisons Uses minimal and efficient logic (O(1)), no heavy loops Produces clean and trade-relevant signals, not visual clutter Designed with algorithmic trading compatibility in mind 📊 Visual Features Clean SMT labels (Bullish / Bearish) Optional connecting lines showing the sweep move Background highlighting for quick contextual awareness Transparent styling to avoid chart obstruction ⚙️ Inputs Second Asset – symbol used for SMT comparison Pivot Length – controls swing sensitivity Max Sync Offset – allowed mismatch between swing points (in bars) Wick Sweep Filter – require close back inside level (ICT-style) ATR Filter – minimum sweep strength Show Lines – toggle visual connections 🧠 How to Use This indicator is best used in: Reversal zones Liquidity pools (equal highs/lows, prior highs/lows) Session highs/lows (London / NY) Typical workflow: Identify SMT signal Wait for confirmation: Break of structure (BOS) Displacement move Execute entry in direction of SMT ⚠️ Notes Signals appear at the moment of liquidity sweep, not at pivot formation This script is non-repainting, as it uses confirmed pivots SMT is not a standalone strategy — use with market structure 🌍 Дополнительно (RU — для твоей аудитории) Этот индикатор реализует правильный SMT, основанный не на HH/LL, а на снятии ликвидности. Ключевая идея: Один актив забирает ликвидность (пробивает свинг) Второй — нет → это и есть настоящий SMT В отличие от большинства индикаторов: нет мусорных сигналов нет перебора всех свингов используется только актуальная структура Лучше всего работает: на хаях/лоу сессий на уровнях ликвидности в связке с BOS / FVG
อินดิเคเตอร์ Pine Script®
โดย crypto_daytrade
MTF-Auto-Triad SMT Engine [TradeSymmetry]MTF-Auto-Triad SMT Engine This indicator puts institutional order flow front and center, featuring an automated Multi-Timeframe (MTF) liquidity divergence engine as its core, supported by built-in helper tools for higher timeframe market structure and momentum tracking. Built to eliminate chart clutter while maximizing actionable data, this tool is engineered for traders executing high-probability, asymmetric setups on intraday execution timeframes. 🔥 Core Feature: The SMT Engine Stop manually typing in comparison tickers every time you switch assets. The Auto-Triad system instantly detects the asset class you are viewing and automatically scans correlated markets for Smart Money Tool (SMT) divergences across multiple timeframes simultaneously. Supported Triads: * Indices: NQ1!, ES1!, YM1! Forex: EURUSD, GBPUSD, DXY Metals: XAGUSD, XAUEUR, XAUGBP, GC1! Oil: CL1!, RB1!, HO1! 🛠 Built-In Helper Tools 1. Dynamic HTF Boxes with Time stamping Keep your higher timeframe narrative locked in while executing on the LTF. Live-Tracking OHLC: Project custom Higher Timeframe boxes (e.g., 1H, 4H, Daily) directly onto your execution chart. Open Time Anchors: The Open level of your HTF box automatically pulls the exact timestamp of when that session began (e.g., 09:30 4H-OPEN), giving you crucial temporal context right at the point of execution. 2. Time-Price Velocity (TPV) Candles Traditional candlesticks only show price action. The TPV engine colors your candles based on mathematically smoothed, ATR-normalized momentum. Identify exactly when momentum is accelerating or decelerating inside a move. Built-in dashboard shows live velocity metrics, trend direction, and acceleration changes. 💡 How to Use This Tool (The TradeSymmetry Setup) This indicator is built to execute a strict, structural trading workflow. Follow these core steps: 1. Identify Your POI & Wait for the Sweep/Tap Frame your narrative and identify your draw on liquidity. Wait patiently for price to sweep a key structural extreme (Session, Daily, Weekly, Monthly Highs/Lows, or Equal Highs/Lows). Alternatively, wait for price to tap into a high-probability Fair Value Gap (FVG) or Order Block (OB). 2. Confirm Institutional Footprints (SMT) Once price reaches your POI, look for an SMT Divergence to print via the Auto-Triad engine. This confirms that correlated assets are failing to make the same high or low—the ultimate footprint of smart money accumulation or distribution. 3. Wait for the Shift & Open Level Validation Look for a clear Market Structure Shift (MSS) or Change in State of Delivery (CISD). Crucial Rule: If you are taking a bullish setup, ensure your trigger candle closes cleanly above the Open level. For a bearish setup, the candle must close cleanly below the Open level. 4. Execute the Trade Once all criteria are met, use the momentum color shift in the TPV candles as your final entry trigger. Target asymmetric risk-to-reward setups (1:3 or 1:5 R:R) based on the next structural draw on liquidity. ⚙️ Customization Everything is modular. Don't want the TPV colors? Turn them off. Want to use a custom 4-asset comparison instead of the Auto-Triads? Switch to Manual mode. Every line and label size can be custom-colored to fit your exact visual style. Trade with symmetry.
อินดิเคเตอร์ Pine Script®
โดย TradeSymmetry
SMT Divergence [UAlgo]SMT Divergence is a comparative market structure indicator designed to detect disagreement between a primary instrument and a second reference symbol. The script looks for situations where the main chart prints a stronger structural move, while the comparison symbol fails to confirm that move. This kind of disagreement is often referred to as SMT divergence and is commonly used to identify potential weakness in continuation or hidden strength into reversal conditions. The script works by tracking confirmed swing highs and swing lows on both instruments. Once enough pivots are stored, it compares the latest structural movement in the primary chart against the latest comparable movement in the reference symbol. If the primary chart makes a lower low while the comparison symbol makes a higher low, the script identifies bullish SMT divergence. If the primary chart makes a higher high while the comparison symbol makes a lower high, the script identifies bearish SMT divergence. What makes this script especially practical is its flexible comparison logic. It can work in a time matched mode, where the comparison swings must occur near the same bars as the primary swings, or in an independent mode, where the script simply uses the most recent valid swings from both instruments. It also supports inverse correlation logic, allowing the user to compare instruments that normally move in opposite directions. The indicator can then display SMT labels directly on the main chart, draw structure lines between the relevant swing points, show a live information table, and optionally render the comparison symbol as candles inside the oscillator pane. This creates a complete workflow for divergence monitoring instead of only printing occasional labels. In practical use, SMT Divergence can help traders identify moments when the primary symbol appears to be making an aggressive structural move without proper confirmation from a related market. These moments can provide useful context for potential exhaustion, liquidity events, or directional imbalance between correlated instruments. 🔹 Features 🔸 Dual Symbol Market Structure Comparison The script compares the active chart against a second user selected symbol. Both instruments are processed using the same pivot logic, which creates a consistent framework for structural comparison. 🔸 Bullish SMT Detection Bullish SMT is identified when the primary chart makes a lower low while the comparison symbol makes a higher low. This can suggest hidden relative strength in the comparison instrument or possible exhaustion in the primary one. 🔸 Bearish SMT Detection Bearish SMT is identified when the primary chart makes a higher high while the comparison symbol makes a lower high. This can suggest weakening confirmation and possible vulnerability in the primary move. 🔸 Positive and Inverse Correlation Modes The script supports both normal and inverse correlation logic. In normal mode, lows are compared with lows and highs are compared with highs. In inverse mode, lows are compared with highs and highs are compared with lows. This makes the tool flexible enough for both positively correlated and negatively correlated markets. 🔸 Time Matched and Independent Swing Modes The user can choose whether swing comparison should require approximate time alignment or simply use the most recent valid swings from each symbol. This allows the script to be either stricter or more flexible depending on the relationship between the two markets. 🔸 Pivot Strength Control Swing highs and lows are built from confirmed pivots using user defined left and right bar settings. This allows the user to control how sensitive or how selective the swing structure should be. 🔸 Minimum Price Difference Filter A minimum price difference percentage can be required before a divergence is accepted. This helps avoid labeling very small and potentially insignificant swing differences. 🔸 Max Swing Memory Control The script stores a limited number of recent swings for both the primary and comparison symbol. This keeps the logic focused on relevant structure and prevents unnecessary buildup of stale pivots. 🔸 On Chart Labels and Lines Detected SMT events can be labeled directly on the main chart. The script can also draw structure lines across the primary and comparison swing legs used in the divergence. 🔸 Live Info Table An information table can display the active comparison symbol, correlation mode, divergence count, and the latest signal direction. This makes the script easier to monitor in real time. 🔸 Optional Compare Candle Panel The comparison symbol can be plotted as candles in the indicator pane. This allows the user to visually inspect whether the second instrument is confirming or rejecting the move seen in the primary chart. 🔸 Alert Support The script includes separate alerts for bullish SMT, bearish SMT, and any SMT event. 🔹 Calculations 1) Defining Swing and Divergence Objects type SwingPoint int barIdx int barTm float price bool isHigh type SMTDivergence int barIdx int barTm bool isBullish float primaryPrice float comparePrice string primarySymbol string compareSymbol label lbl line ln1 line ln2 type SymbolData float h float l float c This is the structural base of the whole script. A SwingPoint stores one confirmed pivot with its bar index, time, price, and whether it is a high or a low. An SMTDivergence object stores the final event once a divergence is confirmed. It keeps the primary and comparison prices, the involved symbols, the direction, and the visual references used for labels and lines. A SymbolData object is used as a clean container for each symbol’s high, low, and close series. So before any logic runs, the script already has a full structure for swing storage and divergence output. 2) Requesting the Comparison Symbol Data = request.security(compareSymbolInput, timeframe.period, , lookahead = barmerge.lookahead_off) SymbolData primaryData = SymbolData.new(high, low, close) SymbolData compareData = SymbolData.new(compareHigh, compareLow, compareClose) This block loads the second symbol on the same chart timeframe. The primary chart uses the current symbol’s own high, low, and close. The comparison symbol is requested with request.security , and its values are placed into a matching data structure. This means both symbols are analyzed on an equal timeframe basis, which is essential for consistent swing comparison. 3) Finding Pivot Highs and Pivot Lows on Both Symbols float primaryPivotHigh = ta.pivothigh(primaryData.h, pivotLeftBars, pivotRightBars) float primaryPivotLow = ta.pivotlow(primaryData.l, pivotLeftBars, pivotRightBars) float comparePivotHigh = ta.pivothigh(compareData.h, pivotLeftBars, pivotRightBars) float comparePivotLow = ta.pivotlow(compareData.l, pivotLeftBars, pivotRightBars) This is the swing discovery engine. The script uses the same pivot settings for both instruments. A pivot high or pivot low is only confirmed after the required number of bars has passed on each side. This means the divergence engine is built from confirmed structure, not from temporary highs and lows that can disappear before confirmation. 4) Storing Swings in Memory method addSwing(array swings, SwingPoint newSwing) => swings.push(newSwing) if swings.size() > maxSwingsToStore swings.shift() swings if not na(primaryPivotHigh) primarySwings.addSwing(SwingPoint.new(bar_index - pivotOffset, time , primaryPivotHigh, true)) if not na(primaryPivotLow) primarySwings.addSwing(SwingPoint.new(bar_index - pivotOffset, time , primaryPivotLow, false)) if not na(comparePivotHigh) compareSwings.addSwing(SwingPoint.new(bar_index - pivotOffset, time , comparePivotHigh, true)) if not na(comparePivotLow) compareSwings.addSwing(SwingPoint.new(bar_index - pivotOffset, time , comparePivotLow, false)) Once a pivot is confirmed, it is pushed into the appropriate swing array. The true pivot bar is pivotRightBars bars in the past, so the script subtracts that offset from the current bar index and time. Each array only keeps the latest user defined number of swings. So the script maintains a rolling structural memory for both markets without allowing the arrays to grow indefinitely. 5) Retrieving the Latest and Previous Swings method getLastSwing(array swings, bool isHigh) => SwingPoint result = na if swings.size() > 0 for i = swings.size() - 1 to 0 SwingPoint sw = swings.get(i) if sw.isHigh == isHigh result := sw break result method getPreviousSwing(array swings, bool isHigh) => SwingPoint result = na int count = 0 if swings.size() > 1 for i = swings.size() - 1 to 0 SwingPoint sw = swings.get(i) if sw.isHigh == isHigh count += 1 if count == 2 result := sw break result These two helper methods are used to build the swing pairs required for divergence detection. getLastSwing returns the most recent high or low swing of the requested type. getPreviousSwing returns the swing before that. This is important because SMT logic always compares two consecutive structure points on the primary side and two corresponding structure points on the comparison side. 6) Enforcing Maximum Distance Between Swing Points method isWithinRange(SwingPoint sw1, SwingPoint sw2) => not na(sw1) and not na(sw2) and math.abs(sw1.barIdx - sw2.barIdx) <= maxBarsLookback This method makes sure the two swings being compared are not too far apart in time. If the latest and previous swing are separated by more than the allowed bar distance, the setup is ignored. This helps keep the analysis focused on fresh and structurally related moves rather than comparing swings that are too old or too distant to be meaningful together. 7) Time Matched Swing Search method findSwingNearBar(array swings, int targetBar, bool isHigh, int toleranceBars) => SwingPoint result = na int minDiff = 999999 if swings.size() > 0 for i = swings.size() - 1 to 0 SwingPoint sw = swings.get(i) if sw.isHigh == isHigh int diff = math.abs(sw.barIdx - targetBar) if diff <= toleranceBars and diff < minDiff minDiff := diff result := sw result This method is used only when the user selects time matched mode. The idea is to find a comparison symbol swing that occurred near the same bar as the primary swing. The script searches for the nearest swing of the correct type inside the allowed tolerance window. So time matched mode is stricter because it requires approximate timing alignment between the two instruments. 8) Minimum Price Difference Filter method pctDiff(float price1, float price2) => math.abs(price1 - price2) / ((price1 + price2) / 2) * 100 This function measures the percentage difference between two prices. The result is later used as an optional minimum swing magnitude filter. If the primary chart’s new swing differs only slightly from its previous one, the script can ignore that divergence candidate. So the minimum difference filter helps reduce weaker signals that are based on very small structure changes. 9) Bullish SMT Detection Logic if not na(primaryPivotLow) and not na(primaryLastLow) and not na(primaryPrevLow) SwingPoint usedCompareLast = na SwingPoint usedComparePrev = na bool targetSwingHigh = inverseCorrelation ? true : false if useTimeMatching usedCompareLast := compareSwings.findSwingNearBar(primaryLastLow.barIdx, targetSwingHigh, timeToleranceBars) usedComparePrev := compareSwings.findSwingNearBar(primaryPrevLow.barIdx, targetSwingHigh, timeToleranceBars) else usedCompareLast := compareSwings.getLastSwing(targetSwingHigh) usedComparePrev := compareSwings.getPreviousSwing(targetSwingHigh) This is the setup stage for bullish SMT. The script only begins the test when a new primary pivot low has just been confirmed and both the latest and previous primary lows are available. Then it decides what kind of comparison swings are needed. In normal correlation mode, bullish SMT compares primary lows to comparison lows. In inverse correlation mode, bullish SMT compares primary lows to comparison highs. Then the script either uses time matched lookup or independent swing retrieval depending on the chosen mode. So before the bullish condition itself is tested, the script first builds the proper comparison pair according to both timing mode and correlation mode. 10) Bullish SMT Confirmation Conditions if not na(usedCompareLast) and not na(usedComparePrev) if primaryLastLow.isWithinRange(primaryPrevLow) bool primaryLL = primaryLastLow.price < primaryPrevLow.price bool compareHL = inverseCorrelation ? (usedCompareLast.price < usedComparePrev.price) : (usedCompareLast.price > usedComparePrev.price) bool meetsMinDiff = minPriceDiff == 0.0 or (primaryLastLow.price.pctDiff(primaryPrevLow.price) >= minPriceDiff) Bullish SMT is confirmed when three things happen. First, the primary chart must make a lower low: primaryLastLow.price < primaryPrevLow.price Second, the comparison symbol must fail to confirm that weakness. In normal correlation mode this means the comparison symbol makes a higher low. In inverse correlation mode the logic is adjusted accordingly because the relationship is reversed. Third, if the minimum difference filter is enabled, the primary low must differ enough from the previous low. So bullish SMT is essentially a lower low in the main chart that is not properly confirmed by the comparison market. 11) Creating the Bullish Divergence Event if primaryLL and compareHL and meetsMinDiff and primaryLastLow.barIdx != lastBullPrimaryIdx bullishSMT := true lastBullPrimaryIdx := primaryLastLow.barIdx SMTDivergence newDiv = SMTDivergence.new(primaryLastLow.barIdx, primaryLastLow.barTm, true, primaryLastLow.price, usedCompareLast.price, syminfo.tickerid, compareSymbolInput, na, na, na) newDiv.drawVisuals(primaryPrevLow.barTm, primaryPrevLow.price, usedCompareLast.barTm, usedComparePrev.barTm, usedComparePrev.price) divergences.push(newDiv) Once the bullish conditions are met, the script creates a new SMT divergence object. It stores the primary swing information, the comparison swing information, the involved symbols, and the bullish direction. Then it calls the visual drawing method and pushes the divergence into the history array. The duplicate protection check against lastBullPrimaryIdx prevents the same primary swing from being labeled repeatedly. 12) Bearish SMT Detection Logic if not na(primaryPivotHigh) and not na(primaryLastHigh) and not na(primaryPrevHigh) SwingPoint usedCompareLastH = na SwingPoint usedComparePrevH = na bool targetSwingHigh = inverseCorrelation ? false : true if useTimeMatching usedCompareLastH := compareSwings.findSwingNearBar(primaryLastHigh.barIdx, targetSwingHigh, timeToleranceBars) usedComparePrevH := compareSwings.findSwingNearBar(primaryPrevHigh.barIdx, targetSwingHigh, timeToleranceBars) else usedCompareLastH := compareSwings.getLastSwing(targetSwingHigh) usedComparePrevH := compareSwings.getPreviousSwing(targetSwingHigh) This is the mirror setup stage for bearish SMT. It begins only when a new primary pivot high has been confirmed and the required primary highs exist. Then it selects the proper comparison swing type according to the chosen correlation mode. In normal correlation mode, bearish SMT compares highs with highs. In inverse correlation mode, bearish SMT compares highs with lows. So this block prepares the correct structural pair for the bearish test. 13) Bearish SMT Confirmation Conditions if not na(usedCompareLastH) and not na(usedComparePrevH) if primaryLastHigh.isWithinRange(primaryPrevHigh) bool primaryHH = primaryLastHigh.price > primaryPrevHigh.price bool compareLH = inverseCorrelation ? (usedCompareLastH.price > usedComparePrevH.price) : (usedCompareLastH.price < usedComparePrevH.price) bool meetsMinDiff = minPriceDiff == 0.0 or (primaryLastHigh.price.pctDiff(primaryPrevHigh.price) >= minPriceDiff) Bearish SMT is confirmed when the primary chart makes a higher high while the comparison symbol fails to confirm that strength. In normal correlation mode, the comparison symbol must make a lower high. In inverse correlation mode the logic is adjusted to preserve the intended structural disagreement. The minimum difference filter is applied here as well. So bearish SMT is the opposite structure of bullish SMT, focused on unconfirmed upside continuation. 14) Creating the Bearish Divergence Event if primaryHH and compareLH and meetsMinDiff and primaryLastHigh.barIdx != lastBearPrimaryIdx bearishSMT := true lastBearPrimaryIdx := primaryLastHigh.barIdx SMTDivergence newDiv = SMTDivergence.new(primaryLastHigh.barIdx, primaryLastHigh.barTm, false, primaryLastHigh.price, usedCompareLastH.price, syminfo.tickerid, compareSymbolInput, na, na, na) newDiv.drawVisuals(primaryPrevHigh.barTm, primaryPrevHigh.price, usedCompareLastH.barTm, usedComparePrevH.barTm, usedComparePrevH.price) divergences.push(newDiv) Once the bearish rules are satisfied, the script creates a bearish SMT divergence object, draws its visuals, and stores it in the divergence history array. The duplicate protection check against lastBearPrimaryIdx prevents repeated labeling of the same primary high. 15) Drawing Labels and Lines method drawVisuals(SMTDivergence div, int prevTime, float prevPrice, int compareTime, int prevCompareTime, float prevComparePrice) => if showLabels string labelText = div.isBullish ? "🔺 SMT" : "🔻 SMT" string tooltipText = str.format("{0} SMT Divergence {1} vs {2} Price: {3}", div.isBullish ? "Bullish" : "Bearish", div.primarySymbol, div.compareSymbol, str.tostring(div.primaryPrice, format.mintick)) color labelColor = div.isBullish ? bullishColor : bearishColor div.lbl := label.new(div.barIdx, div.primaryPrice, labelText, xloc = xloc.bar_index, yloc = div.isBullish ? yloc.belowbar : yloc.abovebar, color = labelColor, textcolor = color.white, style = div.isBullish ? label.style_label_up : label.style_label_down, tooltip = tooltipText, size = size.small, force_overlay = true) if showLines and not na(prevTime) and not na(prevPrice) color lineColor = div.isBullish ? bullishColor : bearishColor div.ln1 := line.new(prevTime, prevPrice, div.barTm, div.primaryPrice, xloc = xloc.bar_time, color = lineColor, width = 2, style = line.style_solid, force_overlay = true) if not na(prevComparePrice) and not na(prevCompareTime) and not na(compareTime) div.ln2 := line.new(prevCompareTime, prevComparePrice, compareTime, div.comparePrice, xloc = xloc.bar_time, color = lineColor, width = 2, style = line.style_solid) This method creates the chart visuals for each divergence. The label is placed directly at the primary swing location, above price for bearish SMT and below price for bullish SMT. If line drawing is enabled, the script also draws one line across the primary chart’s two relevant swing points and another line across the comparison symbol’s swing leg. So the user can see both the signal marker and the underlying structural disagreement that produced it. 16) Limiting Divergence History if divergences.size() > maxDivergencesToShow SMTDivergence rmDiv = divergences.shift() rmDiv.cleanup() This block controls object history. If the stored divergence count exceeds the chosen limit, the oldest divergence is removed from the array and all its visuals are deleted. This keeps the chart clean and prevents unlimited buildup of old labels and lines. 17) Building the Information Table var table infoTable = table.new(position.top_right, 2, 6, bgcolor = color.new(#2222b3, 10), border_width = 1, border_color = color.new(color.white, 80), frame_width = 2, frame_color = color.new(color.white, 70)) if showTable and barstate.islast table.cell(infoTable, 0, 1, "Primary", text_color = color.gray, text_size = size.tiny) table.cell(infoTable, 1, 1, syminfo.tickerid, text_color = color.white, text_size = size.tiny) table.cell(infoTable, 0, 2, "Compare", text_color = color.gray, text_size = size.tiny) table.cell(infoTable, 1, 2, compareSymbolInput, text_color = color.white, text_size = size.tiny) table.cell(infoTable, 0, 3, "Correlation", text_color = color.gray, text_size = size.tiny) table.cell(infoTable, 1, 3, inverseCorrelation ? "Inverse" : "Positive", text_color = inverseCorrelation ? color.orange : color.aqua, text_size = size.tiny) table.cell(infoTable, 0, 4, "Divergences", text_color = color.gray, text_size = size.tiny) table.cell(infoTable, 1, 4, str.tostring(divergences.size()), text_color = color.white, text_size = size.tiny) This table provides a compact real time summary. It shows: the primary symbol, the comparison symbol, the current correlation mode, the number of stored divergences, and the most recent signal direction. So the table functions as a monitoring dashboard rather than only a decorative element. 18) Determining the Last Signal for the Table string lastSignal = "None" color signalColor = color.gray if divergences.size() > 0 SMTDivergence lastDiv = divergences.get(divergences.size() - 1) lastSignal := lastDiv.isBullish ? "🔺 Bullish" : "🔻 Bearish" signalColor := lastDiv.isBullish ? bullishColor : bearishColor This block determines what the table should show as the latest signal. If at least one divergence has been stored, the script reads the newest one and displays whether it was bullish or bearish, along with the corresponding color. So the info table always reflects the current state of the divergence history. 19) Alert Conditions alertcondition(bullishSMT, title = "Bullish SMT Divergence", message = "🔺 Bullish SMT Divergence detected on {{ticker}}! Primary made Lower Low while {{interval}} comparison made Higher Low.") alertcondition(bearishSMT, title = "Bearish SMT Divergence", message = "🔻 Bearish SMT Divergence detected on {{ticker}}! Primary made Higher High while {{interval}} comparison made Lower High.") alertcondition(bullishSMT or bearishSMT, title = "Any SMT Divergence", message = "SMT Divergence detected on {{ticker}}!") The script provides three alert types. One triggers only on bullish SMT. One triggers only on bearish SMT. One triggers on any SMT event. This makes the indicator useful both for visual study and for live event monitoring. 20) Compare Candle Panel color compareBodyColor = compareClose >= compareOpen ? color.new(#00E676, 0) : color.new(#FF5252, 0) color compareWickColor = compareClose >= compareOpen ? color.new(#00E676, 30) : color.new(#FF5252, 30) color compareBorderColor = compareClose >= compareOpen ? color.new(#00C853, 0) : color.new(#D50000, 0) plotcandle(compareOpen, compareHigh, compareLow, compareClose, title = "Compare Symbol Candles", color = compareBodyColor, wickcolor = compareWickColor, bordercolor = compareBorderColor, display = showCandlePanel ? display.all : display.none) This block renders the comparison symbol as candles inside the indicator pane. The candle colors are determined by the comparison symbol’s own open and close direction. If the user enables the candle panel, this gives a quick visual reference for how the second instrument is behaving without needing to open a separate chart. So the user can study SMT signals and the comparison structure in the same pane.
อินดิเคเตอร์ Pine Script®
โดย UAlgo
1
SMT Divergence & ICT KillzonesOverview This open-source indicator combines SMT-style divergence detection, ICT killzone context, and a Midnight Open reference on a single chart. It is intended for users who want to review correlation-based divergence conditions together with fixed New York session timing and a daily reference level in one workflow. Why this script was created This script was created to reduce the need to switch between separate tools for SMT comparison, session timing, and daily reference levels. Instead of checking these elements one by one, the indicator keeps them on the same chart so they can be reviewed together. How it works The script compares confirmed swing highs and lows on the chart symbol with those of a user-selected comparison symbol. When one market confirms a new swing extension while the comparison market does not confirm a similar extension, the script marks an SMT-style divergence condition. In addition to the divergence logic, the script highlights London and New York killzone windows using fixed New York session timing and plots Midnight Open as a daily reference line. Signals are based on confirmed pivots, so they appear after confirmation rather than on the exact turning bar. How to use it Choose a comparison symbol that has a meaningful relationship with the chart symbol. For example, users may compare BTCUSDT with ETHUSDT, or use other markets that are commonly reviewed together. A practical way to use the script is to review SMT signals together with the killzone background and the Midnight Open level rather than treating the signal marker by itself as a complete trade decision. Standard candlestick charts are recommended for visual consistency. Inputs Correlation Symbol — Selects the market used for SMT comparison. The most useful results usually come from symbols with a meaningful relationship to the chart symbol. Timeframe — Sets the timeframe used for the comparison symbol. If left empty, the chart timeframe is used. Using a different timeframe changes how often comparison pivots update and can change the timing of divergence markings. Swing Length — Controls pivot confirmation sensitivity. Higher values require more bars to confirm a pivot, which usually produces fewer signals and more delay. Lower values react faster but can produce more frequent signals. Show Killzone Background — Shows or hides the London and New York killzone background. Show Midnight Open — Shows or hides the Midnight Open reference line. Display Timezone — Controls the display-related timezone behavior used where applicable. Killzone calculations remain aligned to New York session timing. Bearish / Bullish Color — Sets the visual colors of bearish and bullish SMT markings. Outside Killzone Transparency — Reduces the visual emphasis of signals that form outside killzone windows. Increasing this value makes off-session signals less visually prominent. Max Historical Objects — Limits how many historical SMT drawings remain on the chart at the same time. Lower values keep the chart cleaner, while higher values preserve more historical context. How changing the settings affects the output Increasing Swing Length makes pivot confirmation stricter. This usually reduces the number of signals, but it also delays them further. Lowering Swing Length makes the script react faster, but it can also increase the number of marked conditions. Changing the Correlation Symbol changes the relationship being evaluated. Closely related markets are usually easier to interpret than unrelated ones. Changing the Timeframe for the comparison symbol changes the pace at which comparison pivots form, which can materially change when divergence conditions appear. Increasing Outside Killzone Transparency makes off-session signals less visually prominent. Reducing Max Historical Objects removes older drawings sooner and keeps the chart cleaner. Use context This script is most useful when the chart symbol and comparison symbol have a meaningful relationship and when session timing matters in the user’s workflow. It is designed to help users review divergence conditions together with session context and a daily reference level, rather than isolate them as separate tools. Limitations The usefulness of the output depends heavily on the chosen comparison symbol. Weakly related or unrelated symbols can reduce the value of SMT readings. Because the logic uses confirmed pivots, signals appear after confirmation rather than on the exact turning bar. In sideways or choppy conditions, divergence readings can become less informative. Heikin Ashi, Renko, Line Break, Kagi, Point & Figure, and Range charts can produce less reliable visual interpretation because they do not use standard price construction. Design notes This script combines confirmed SMT-style comparison logic, fixed ICT killzone timing tied to New York session hours, and a Midnight Open reference in one workflow. It also manages historical lines and labels so the chart does not keep accumulating drawings without limit, which helps keep the visual layout more controlled over time.
อินดิเคเตอร์ Pine Script®
โดย malibuuu
3
ICT Concepts [UAlgo]ICT Concepts is a broad market structure toolkit that combines several core ICT style elements inside a single script. Instead of focusing on only one concept, the indicator brings together order blocks, market structure shifts, SMT divergence, fair value gaps, balanced price ranges, consequent encroachment, liquidity sweeps, Fibonacci levels, and killzones in one integrated overlay. The script is designed for traders who want a consolidated structure map rather than a collection of separate indicators. It tracks swing highs and lows, labels structural breaks as BOS or MSS, detects order blocks from a strict candle pattern, identifies imbalances through fair value gap logic, monitors liquidity sweeps around recent pivot levels, and draws structure anchored Fibonacci levels from the latest confirmed break. It can also compare the active chart against a second symbol for SMT divergence and even render a small comparison panel directly on the chart. One of the strongest qualities of this script is that each module is state aware. Order blocks extend until mitigation. Fair value gaps extend until price trades through them. Structure anchors update after new breaks. Killzones persist historically for a defined number of sessions. SMT events are stored, labeled, and optionally projected inside a mini comparison panel. This makes the script much more than a simple set of static drawings. It behaves like a live structural framework that evolves with price. From a workflow point of view, the indicator is especially useful for traders who want to read context in layers. Structure tells whether price is breaking with trend or shifting against it. Order blocks and imbalances show where inefficiency or sponsorship may remain. Liquidity sweeps show where recent resting liquidity has likely been taken. Fibonacci levels frame premium, discount, equilibrium, and OTE areas relative to the latest structural move. Killzones add time based session context. Together, these components create a broad market map for discretionary analysis. 🔹 Features 🔸 Single Candle Order Block Detection The script detects bullish and bearish order blocks using a strict three candle displacement pattern. When a valid setup appears, the order block is stored, extended forward, and removed only after mitigation. Optional mean threshold lines can also be shown inside each block. 🔸 Multi Timeframe Order Blocks Order block detection can run on a selected timeframe through request.security . This allows higher timeframe order blocks to be projected onto the current execution chart. 🔸 Market Structure Mapping The indicator tracks pivot highs and lows and labels confirmed structural breaks as BOS or MSS. A continuation break is labeled BOS, while a directional reversal break is labeled MSS. This gives the chart a clear structure narrative. 🔸 SMT Divergence Detection The script can compare the active chart against a second symbol and detect SMT divergence using pivot highs and lows from both instruments. Divergences are labeled directly on the main chart and can also be reflected inside a mini comparison panel. 🔸 Fair Value Gaps Bullish and bearish fair value gaps are detected through a classic three candle gap condition. These imbalances are stored, extended, and removed once mitigated. 🔸 Balanced Price Range Support When a new fair value gap overlaps with an opposite side historical fair value gap, the overlapping section becomes a balanced price range. This gives the script the ability to detect conflict zones formed by opposing inefficiencies. 🔸 Consequent Encroachment Mode The imbalance module can also be displayed in consequent encroachment mode, where the midpoint of the gap is shown along with the premium or discount half of the imbalance. 🔸 Liquidity Sweep Detection The indicator monitors recent pivot highs and lows and marks when price trades beyond one of those levels but closes back through it. This makes it easy to spot local buy side and sell side sweeps. 🔸 Structure Anchored Fibonacci Levels After a confirmed structural break, the script anchors Fibonacci levels between the break extreme and the opposing structural point. Equilibrium, OTE, and optional extra levels are then projected forward. 🔸 Killzone Rendering The script can mark Asian, London, New York AM, and New York PM session windows using session boxes and optional session range lines. Historical session boxes are kept for a user defined number of prior occurrences. 🔸 Active Object Management Each subsystem uses its own storage and cleanup logic. Order blocks, imbalances, SMT markers, liquidity sweep boxes, Fibonacci objects, and killzones are all managed so the chart remains usable over time. 🔸 Alerts Alert conditions are included for bullish and bearish order block detection. 🔹 Calculations 1) Order Block Pattern Logic detectLogic() => bool isBull = open > close and close > open and close > open and low < low and close > high bool isBear = open < close and close < open and close < open and high > high and close < low [isBull, high , low , time , isBear, high , low , time ] This is the core order block detector. A bullish order block requires: a bearish candle at 2 , a bullish candle at 1 , a bullish current candle, a sweep below the low of candle 2 by candle 1 , and a close above the high of candle 1 . A bearish order block uses the exact inverse. The returned zone bounds come from candle 1 , which becomes the order block candle. That is why the function returns high , low , and time . So the script is not marking every displacement candle. It is looking for a very specific three candle formation. 2) Multi Timeframe Order Block Projection = request.security(syminfo.tickerid, i_tf, detectLogic()) This line runs the order block detection logic on the selected timeframe. If the user chooses a higher timeframe, the resulting order block values are projected onto the current chart. This is extremely useful for mapping higher timeframe sponsorship zones onto a lower timeframe execution environment. So the detection can stay structurally higher while the display remains on the user’s active chart. 3) Preventing Overlapping Order Blocks method hasOverlap(array OBs, float top, float bottom) => bool overlap = false if OBs.size() > 0 for i = 0 to OBs.size() - 1 OB item = OBs.get(i) if (top < item.top and top > item.bottom) or (bottom > item.bottom and bottom < item.top) overlap := true break overlap Before a new order block is added, the script checks whether it overlaps an existing stored block of the same side. If the proposed top or bottom falls inside an existing block, the new one is ignored. This reduces clutter and helps avoid stacking multiple highly similar zones in the same area. So the order block engine is selective not only in detection, but also in object creation. 4) Order Block Mitigation and Active Limit Handling method isMitigated(OB this, float currentClose) => this.isBull ? (currentClose < this.bottom) : (currentClose > this.top) if drawCount < OB_ACTIVE_LIMIT if na(item.id) item.draw(i_bullColor, "Bull OB", i_showMidLine) item.extend() drawCount += 1 else item.remove() An order block remains valid until price closes beyond its invalidation boundary. For bullish order blocks, mitigation happens when close moves below the block bottom. For bearish order blocks, mitigation happens when close moves above the block top. The script also limits how many active blocks are actually drawn. Older stored blocks may remain in memory, but only the most recent valid ones stay visible. This keeps the chart clean while preserving logic continuity. 5) Market Structure Pivot Tracking float ph = ta.pivothigh(i_structLen, i_structLen) float pl = ta.pivotlow(i_structLen, i_structLen) if not na(ph) prevHigh := lastHigh prevHighIndex := lastHighIndex lastHigh := ph lastHighIndex := bar_index if not na(pl) prevLow := lastLow prevLowIndex := lastLowIndex lastLow := pl lastLowIndex := bar_index This is the base structure engine. The script identifies confirmed pivot highs and lows using the selected pivot length. When a new pivot is confirmed, the prior stored high or low becomes prevHigh or prevLow , and the newest one becomes lastHigh or lastLow . This means the indicator always keeps a rolling memory of the latest structural extremes, which later become the reference levels for BOS, MSS, liquidity sweeps, and Fibonacci anchoring. 6) BOS and MSS Logic bool brokenHigh = ta.crossover(close, lastHigh) bool brokenLow = ta.crossunder(close, lastLow) if brokenHigh and not na(lastHigh) and not lastHighBroken if not trendInitialized or trendIsBullish drawStructure(lastHighIndex, lastHigh, bar_index, lastHigh, "BOS", i_structBull, "solid") else drawStructure(lastHighIndex, lastHigh, bar_index, lastHigh, "MSS", i_structBull, "dashed") if brokenLow and not na(lastLow) and not lastLowBroken if not trendInitialized or not trendIsBullish drawStructure(lastLowIndex, lastLow, bar_index, lastLow, "BOS", i_structBear, "solid") else drawStructure(lastLowIndex, lastLow, bar_index, lastLow, "MSS", i_structBear, "dashed") This is how the script classifies structure. If close breaks above the last confirmed high, price has broken bullish structure. If close breaks below the last confirmed low, price has broken bearish structure. The label depends on prior trend state. If the break happens in the same directional regime, it is labeled BOS. If the break happens against the prior regime, it is labeled MSS. So BOS means continuation of prevailing structure, while MSS means a shift in directional character. 7) SMT Divergence Detection float smtPhA = i_smtOn ? ta.pivothigh(high, i_smtLen, i_smtLen) : na float smtPlA = i_smtOn ? ta.pivotlow(low, i_smtLen, i_smtLen) : na float smtPhB = i_smtOn ? request.security(i_smtSymbol, timeframe.period, ta.pivothigh(high, i_smtLen, i_smtLen)) : na float smtPlB = i_smtOn ? request.security(i_smtSymbol, timeframe.period, ta.pivotlow(low, i_smtLen, i_smtLen)) : na This block builds pivot data for both the main symbol and the comparison symbol. The idea of SMT is relative disagreement. If one market makes a stronger high while the other fails to confirm it, or one market makes a lower low while the other refuses to follow, divergence may be present. The script therefore tracks pivot highs and lows separately for both instruments. 8) Bearish and Bullish SMT Conditions bool bearishSmt = not na(smtAHighPrev) and not na(smtBHighPrev) and (smtAHighLast > smtAHighPrev) and (smtBHighLast <= smtBHighPrev) bool bullishSmt = not na(smtALowPrev) and not na(smtBLowPrev) and (smtALowLast < smtALowPrev) and (smtBLowLast >= smtBLowPrev) These are the actual divergence tests. Bearish SMT occurs when the active chart makes a higher high while the comparison symbol fails to do so. Bullish SMT occurs when the active chart makes a lower low while the comparison symbol fails to confirm that weakness. So the script is looking for asymmetry between related instruments, which is one of the classic uses of SMT analysis. 9) Mini Panel Rendering for SMT = request.security(i_smtSymbol, timeframe.period, ) drawMiniCandle(startX + (lookback - 1 - i), o, h, l, c, smtMin, smtRange, baseY, targetHeight, i_smtBull, i_smtBear, isBear, isBull) The mini panel is built by requesting OHLC data for the comparison symbol, then compressing it into a custom candle panel drawn on the right side of the chart. Each mini candle is scaled into panel coordinates using the comparison symbol’s own high and low range. SMT event bars are then marked inside that mini chart. So the panel is not decorative only. It provides a quick structural view of the comparison symbol directly beside the main chart. 10) Fair Value Gap Detection bool fvgBullDetected = low > high bool fvgBearDetected = high < low These are the fair value gap rules. A bullish fair value gap exists when the current low is above the high from two bars ago. A bearish fair value gap exists when the current high is below the low from two bars ago. This is the classic three candle inefficiency model. The gap zone is then stored as an FVG object and extended forward until mitigation. 11) Balanced Price Range Logic bool hasOverlap = fTop > existing.bottom and fBot < existing.top if hasOverlap float bprTop = math.min(fTop, existing.top) float bprBot = math.max(fBot, existing.bottom) When a newly detected fair value gap overlaps an opposite side historical fair value gap, the overlapping area becomes a balanced price range. This is important because BPR is not detected as an isolated standalone pattern. It is formed from the intersection of opposing inefficiencies. The script extracts only the common overlapping region and stores it as a new BPR object. So BPR here is derived from actual imbalance conflict. 12) Consequent Encroachment Logic float ceLevel = (this.top + this.bottom) / 2 float boxTop = this.isBull ? ceLevel : this.top float boxBot = this.isBull ? this.bottom : ceLevel Consequent encroachment is the midpoint of the fair value gap. The script calculates the midpoint and, when CE mode is enabled, draws both a dashed midpoint line and a half gap box. For bullish gaps it emphasizes the lower half up to midpoint. For bearish gaps it emphasizes the upper half down to midpoint. So CE mode gives the user a more precise internal level inside the wider imbalance. 13) Fair Value Gap Mitigation method isMitigated(FVG this, float currentHigh, float currentLow) => this.isBull ? (currentLow < this.bottom) : (currentHigh > this.top) A bullish fair value gap is mitigated when price trades below its bottom. A bearish fair value gap is mitigated when price trades above its top. Once mitigation happens, the object is removed. This keeps the imbalance display focused on still relevant inefficiencies. 14) Liquidity Sweep Detection float liqPh = ta.pivothigh(LIQ_PIVOT_LEN, 1) float liqPl = ta.pivotlow(LIQ_PIVOT_LEN, 1) bool sweepBull = i_showLiq and not na(liqLastLow) and not liqLastLowSwept and low < liqLastLow and close > liqLastLow bool sweepBear = i_showLiq and not na(liqLastHigh) and not liqLastHighSwept and high > liqLastHigh and close < liqLastHigh This module watches recent pivot highs and lows for sweep behavior. A bullish liquidity sweep occurs when price trades below the most recent sell side liquidity level but closes back above it. A bearish liquidity sweep occurs when price trades above the most recent buy side liquidity level but closes back below it. This is a clean wick through and reclaim style sweep model. 15) Liquidity Sweep Box Construction if sweepBull line bullSweepLine = line.new(liqLastLowIndex, liqLastLow, bar_index, liqLastLow, color = i_liqSellsideCol, style = line.style_solid) box bullSweepBox = liqNewSweepBox(liqLastLow, low, i_liqSellsideCol) if sweepBear line bearSweepLine = line.new(liqLastHighIndex, liqLastHigh, bar_index, liqLastHigh, color = i_liqBuysideCol, style = line.style_solid) box bearSweepBox = liqNewSweepBox(high, liqLastHigh, i_liqBuysideCol) When a sweep occurs, the script draws two things: a line showing the swept liquidity level, and a box covering the swept excursion beyond that level. This makes the sweep visually clear by showing both the reference price and the actual penetration area. 16) Fibonacci Anchoring From Latest Structure Break bool fibCanDraw = i_showFib and lastStructBreakDir != 0 and not na(lastStructBreakIndex) and not na(lastStructBreakExtreme) and not na(lastStructOppPrice) and not na(lastStructOppIndex) and lastStructOppIndex != 0 The Fibonacci engine only draws when a valid structural break context exists. The anchor requires: a known break direction, the latest break index, the break extreme, the opposing structural price, and the opposing structural index. So Fibonacci is not anchored arbitrarily. It is tied directly to the latest confirmed structural move. 17) Fibonacci Level Calculation float a0 = lastStructBreakExtreme float a1 = lastStructOppPrice float r = a1 - a0 float p0 = a0 + r * 0.0 float p1 = a0 + r * 1.0 float pEq = a0 + r * i_fibEqLevel float pOteLow = a0 + r * i_fibOteLow float pOteMid = a0 + r * i_fibOteMid float pOteHigh = a0 + r * i_fibOteHigh This is the actual Fibonacci math. The script defines the range between the break extreme and the opposing structural point, then calculates all Fibonacci levels as proportions of that range. That includes: the zero level, the one level, equilibrium, the OTE low, the OTE midpoint, and the OTE high. Optional extra levels can also be added in the same way. So the Fibonacci framework always adapts to the latest structural swing rather than staying fixed to older price action. 18) Killzone Session Detection string kzTz = "UTC-5" kzInSession(string sess) => not na(time(timeframe.period, sess, kzTz)) bool inAsian = kzInSession("2000-0000") bool inLondon = kzInSession("0200-0500") bool inNY = kzInSession("0830-1100") bool inLondonC = kzInSession("1330-1600") Killzones are detected through session time windows defined in UTC 5. Each session is converted into a boolean state that says whether the current bar falls inside that time window. This becomes the input for the killzone renderer. So session marking is time based rather than manually positioned. 19) Killzone Box and Range Update Logic if isActive if not wasActive or na(sBox) sBox := box.new(left = time, top = high, right = time, bottom = low, xloc = xloc.bar_time, bgcolor = baseCol, border_color = color(na), border_width = 0, text = boxTxt, text_color = tC, text_size = size.tiny, text_halign = text.align_left, text_valign = text.align_top) float prevTop = box.get_top(sBox) float prevBot = box.get_bottom(sBox) float newTop = math.max(prevTop, high) float newBot = math.min(prevBot, low) box.set_top(sBox, newTop) box.set_bottom(sBox, newBot) box.set_right(sBox, time) When a killzone begins, the script creates a new box using the current bar’s range. As the session continues, it keeps updating the top and bottom to reflect the highest high and lowest low made during that session. So each killzone box becomes both a time marker and a session range marker.
อินดิเคเตอร์ Pine Script®
โดย UAlgo
3
SMT Divergence Strength Index [Metrify]This indicator detects SMT-style divergence between the chart symbol and a user-defined reference symbol, then filters those divergence events using a statistical strength condition. The goal is to separate ordinary pivot mismatches from divergence events that occur during unusually large relative movement between the two instruments. It combines three components in one script: pivot-based divergence detection, Z-score normalization of momentum spread, and a correlation plot for context. The output is an oscillator panel (Z-score columns + correlation line) plus optional SMT labels/lines drawn on the main chart. SMT divergence logic (structural layer) The structural part of the script is based on confirmed pivots on the main symbol. For bearish SMT detection, the script checks whether the main symbol forms a higher high while the reference symbol (evaluated at the same pivot event point) forms a lower high relative to the previous corresponding pivot event. For bullish SMT detection, it checks whether the main symbol forms a lower low while the reference symbol forms a higher low Reference symbol and inversion The Reference Symbol (Pairing) input defines the market used for comparison. The usefulness of the divergence output depends heavily on this pairing. The script assumes the comparison is meaningful enough that non-confirmation between the two symbols can be interpreted as a potential imbalance or relative weakness/strength event. The 'Invert Correlation' option transforms the reference data by using reciprocal values before the divergence and correlation calculations. This can be used when analyzing pairs that are expected to move inversely (like alt to btc in specific event), so the comparison orientation better matches the intended relationship. Invert Correlation mode (what it does and why it exists) The Invert Correlation option changes how the reference symbol is transformed before all downstream calculations (pivot comparison, momentum spread, Z-score, and correlation plot). When enabled, the script does not compare the main symbol to the raw reference prices. Instead, it compares against the reciprocal form of the reference series: reference high is transformed using 1 / low reference low is transformed using 1 / high reference close is transformed using 1 / close This inversion is used so that an inversely related market can be analyzed in the same directional framework as a positively correlated one. In practical terms, it converts an opposite direction relationship into a comparable orientation for SMT logic. After inversion, moves that would normally appear opposite can be interpreted as if they were aligned, allowing the same higher-high / lower-high and lower-low / higher-low SMT structure rules to be applied consistently. Conceptually, invert mode is useful when your reference asset is expected to move opposite to the main asset and you want the script to evaluate non-confirmation in a unified SMT framework. It does not automatically improve signal quality, but simply changes the orientation of the comparison so the divergence logic matches the relationship you are trying to study. Use normal mode when the pair is usually expected to move in the same direction. Use invert mode when the pair is usually expected to move in opposite directions (or when your analysis framework treats one as a risk-off mirror of the other). Good inversion-pair examples (practical) 1) Risk asset vs Dollar Index (DXY) This is one of the cleanest concepts for inversion. BTCUSD vs DXY ETHUSD vs DXY OIL VS DXY NASDAQ (NDX / US100) vs DXY Gold vs DXY (often inverse, but can break regime) When DXY rises, risk assets often weaken. Inverting DXY makes the reference move in the same orientation as the risk asset. 2) Equity index vs VIX Very common inverse relationship idea. SPX / ES / NQ vs VIX BTC (sometimes) vs VIX as a broader risk proxy (less direct, more regime dependent) Why inversion helps: VIX is typically "fear up when equities down". Inverted VIX can be used as a proxy for risk-on alignment. 3) USD-quoted asset vs USD strength proxy If your main symbol is sensitive to USD strength: XAUUSD vs DXY EURUSD vs DXY GBPUSD vs DXY AUDUSD vs DXY These are classic macro pairings where inversion often makes analytical sense. 4) Some commodity currencies vs commodity / dollar drivers (case-by-case) Examples can work, but are more conditional: USDCAD vs Oil (WTI) (often inverse-ish relationship via CAD/oil linkage) AUDUSD vs Copper (sometimes) NZDUSD vs risk proxy These are not as stable as DXY/VIX examples, so you need to monitor correlation more carefully. Trigger conditions in plain terms A bearish SMT label appears only when all required conditions are satisfied: a confirmed pivot high exists on the main symbol, the current main pivot high is higher than the previous main pivot high, the aligned reference high at the same pivot event is lower than its previous aligned reference high, and the Z-score condition exceeds the configured threshold. A bullish SMT label follows the mirrored condition/vice versa. Display behavior and non-repaint option The indicator uses confirmed pivots, so signals are known only after pivot confirmation. The Non repaint mode setting controls how labels are displayed: Enabled: labels are shown on the trigger/confirmation bar (the bar where the pivot is confirmed and the signal becomes true). Disabled: labels are shifted back to the pivot bar for visual alignment. This setting affects visualization only. It does not change the underlying pivot confirmation process. This indicator marks pivot-based intermarket non-confirmation events that occur during statistically elevated relative dislocation. Pair selection remains a major source of variation in output quality. Weakly related pairs can produce divergence labels that satisfy the script’s rules but are not analytically useful.
อินดิเคเตอร์ Pine Script®
โดย Metrify
NQ Hourly Connected Flat BlocksThis indicator is designed for NQ (Nasdaq-100) and high-volatility futures traders who need a clean, distraction-free view of Hourly Market Structure. Unlike standard scripts that "staircase" every time a new high is hit, this script utilizes dynamic line-object management to keep hourly levels perfectly flat and connected. Key Features Static In-Period Ranges: The High and Low lines for the current hour remain perfectly horizontal. If a new high is hit, the entire line for that hour shifts up, maintaining a "Block" visual rather than a jagged staircase. Vertical Connectivity: Hours are bridged by vertical connectors at the period transitions, allowing you to visualize "Liquidity Steps" as the market expands or contracts. Midpoint (Equilibrium) Line: Includes a dashed 50% retracement level for every hour, essential for determining if price is in a "Premium" or "Discount" zone relative to the current hour's range. Zero Offset: Levels are pinned directly to the candles that created them, providing real-time feedback on range expansion. How to Trade It Liquidity Sweeps: Watch for price to wick above the Green High line and immediately reclaim the previous level. This often signals a "Stop Run" before a reversal. The "Ladder" Trend: In strong trending environments, you will see the "Blocks" create a staircase pattern. Use the Midpoint as a trailing support/resistance level. Volatility Contraction: When the distance between the Green and Red lines is narrow compared to previous hours, anticipate an explosive breakout.
อินดิเคเตอร์ Pine Script®
โดย bansheecapital
CandelaCharts - SMT 📝 Overview The CandelaCharts – SMT indicator is a professional-grade Smart Money Technique (SMT) divergence detector designed to compare price action between correlated markets (intermarket analysis). It identifies moments where the main chart makes a swing high or low while one or more comparison symbols fail to confirm the move—revealing potential institutional imbalance, distribution, or accumulation . By automatically detecting pivot-based divergences and drawing clean, contextual lines and labels directly on price, SMT helps traders spot high-probability reversal or continuation zones driven by relative strength and weakness across markets. 📦 Features Automatic SMT divergence detection – Identifies divergences between the main chart and up to two comparison symbols. Pivot-based logic – Uses swing highs and swing lows to ensure structurally meaningful SMT signals. Dual-symbol comparison – Compare the main market against one or two correlated instruments simultaneously. Bullish & bearish SMT filtering – Show only bullish, bearish, or both divergence types. Clear visual mapping – Divergence lines are drawn directly between pivots for intuitive price-context reading. Smart labels – Compact labels display symbol(s), volume, and directional markers. Detailed tooltips – Hover tooltips include divergence type, symbols involved, prices, volume, timestamps, and pivot settings. Highly customizable visuals – Control colors, line width, and label styling. ⚙️ Settings Lookback – Pivot lookback length used to detect swing highs and lows. Higher values produce fewer but more significant SMT signals. Bias – Control which SMTs are displayed: Both, Bearish or Bullish Swing High Color – Line and label color for SMT at swing highs. Swing Low Color – Line and label color for SMT at swing lows. Line Width – Thickness of SMT divergence lines. Symbol 1 – Enable and select the first comparison instrument (e.g., NQ vs ES). Symbol 2 – Enable and select the second comparison instrument (optional). ⚡️ Showcase Bullish and Bearish SMTs Bearish SMTs Bullish SMTs 🚨 Alerts This indicator does not include built-in alert conditions. ⚠️ Disclaimer This indicator is provided for educational and informational purposes only and does not constitute financial or investment advice. Trading and investing involve substantial risk, and losses can exceed expectations. Past performance is not indicative of future results. You are solely responsible for your trading decisions. CandelaCharts assumes no liability for any outcomes resulting from the use of this indicator.
อินดิเคเตอร์ Pine Script®
โดย CandelaCharts
SMT Divergence [Kodexius]SMT Divergence is a correlation-based divergence detector built around the Smart Money Technique concept: when two normally correlated instruments should be making similar swing progress, but one prints a new extreme while the other fails to confirm it. This “disagreement” can be a valuable contextual signal around liquidity runs, distribution phases, and potential reversal or continuation points. The script compares the chart symbol (primary) with a user-selected comparison symbol (for example BTC vs ETH, ES vs NQ, EUR/USD vs GBP/USD) and automatically scans both instruments for confirmed swing highs and swing lows using pivot logic. Once swings are established, it checks for classic SMT conditions: Primary makes a new swing extreme while the comparison symbol forms a non-confirming swing . To support a wider range of markets, the indicator includes an Inverse Correlation option for pairs that typically move opposite to each other (for example DXY vs EUR/USD). With this enabled, the divergence rules are logically flipped so that the script still detects “non-confirmation” in a way that is consistent with the pair’s relationship. The indicator is designed to be readable and actionable. It can draw divergence labels directly on the main chart, connect the relevant swing points with lines, show a compact information table with the last signal and settings, and optionally render the comparison symbol as a mini candle chart in the indicator pane for quick visual validation. 🔹 Features 🔸 Two-Symbol SMT Analysis (Primary vs Compare) Select any comparison symbol to evaluate correlation structure and divergence. The script fetches the comparison OHLC data using the current chart timeframe to keep both series aligned for analysis. 🔸 Inverse Correlation Mode For inversely correlated pairs, enable “Inverse Correlation” so the script interprets confirmation appropriately (for example, a higher low on the comparison instrument might be expected to correspond to a lower low on the primary, depending on the relationship). This helps avoid false conclusions when the pair naturally moves opposite. 🔸 Pivot-Based Swing with Adjustable Sensitivity Swings are detected using confirmed pivots (left bars and right bars). This provides cleaner structural swing points compared with raw candle-to-candle comparisons, and it lets you control sensitivity for different market conditions and timeframes. The script also limits stored swing history to keep performance stable. 🔸 Flexible Detection Mode: Time Matched or Independent Swings You can choose how swings are paired across instruments: Time Matched searches for a comparison swing that occurred at the same pivot time as the primary swing. Independent Swings compares each symbol’s own last two swings without requiring an exact time match. 🔸 Range Control and Noise Filtering To reduce weak or irrelevant signals: “Max Bars Between Swings” ensures the two swings being compared are close enough in structure to be meaningful. “Min Price Diff (%)” can require a minimum percentage change between the primary’s last two swing prices to confirm the move is significant. 🔸 Clear Visual Output with Tooltips When a divergence is detected, the script can print a label (“SMT”) with bullish or bearish styling and a tooltip that includes the symbol pair and the primary swing price for quick context. 🔸 Divergence Lines for Context Optional lines connect the relevant swing points, making it easier to see the exact structure that triggered the signal. One line can be drawn on the main chart and another in the indicator pane for the comparison series. 🔸 Info Table (At a Glance) A compact table can display the active symbols, correlation mode, total divergences stored, and the most recent signal type. 🔸 Alerts Included Built-in alert conditions are provided for bullish SMT, bearish SMT, and any SMT event so you can automate notifications without editing the code. 🔸 Optional Comparison Candle Panel If enabled, the indicator can plot the comparison symbol as candles in the indicator pane. This is useful for confirming whether the divergence is happening around major levels, consolidations, or impulsive legs on the secondary instrument. 🔹 Calculations This section summarizes the core logic used by the script. 1. Data Synchronization (Comparison Symbol) The comparison instrument is requested on the chart’s current timeframe so swing calculations are performed consistently: = request.security(compareSymbolInput, timeframe.period, ) This ensures pivots and swing times are derived from the same bar cadence as the primary chart. 2. Swing Detection via Confirmed Pivots Swings are detected using pivot logic with user-defined left and right bars: primaryPivotHigh = ta.pivothigh(high, pivotLeftBars, pivotRightBars) primaryPivotLow = ta.pivotlow(low, pivotLeftBars, pivotRightBars) Because pivots are confirmed only after the “right bars” have closed, the script stores each swing using an offset so the swing’s bar index and time reflect where the pivot actually occurred, not where it was confirmed. 3. Swing Storage and Retrieval Both symbols maintain arrays of SwingPoint objects. Each new swing is pushed into the array, and older swings are dropped once the array exceeds the configured maximum. This makes the divergence engine predictable and prevents uncontrolled memory growth. The script then retrieves the last and previous swing highs and lows (per symbol) to evaluate structure. 4. Matching Logic (Time Matched vs Independent) When “Time Matched” is selected, the script searches the comparison swing array for a pivot that occurred at the exact same timestamp as the primary swing. When “Independent Swings” is selected, it simply uses the comparison symbol’s last two swings of the same type. 5. Bullish SMT Condition (LL vs HL) A bullish SMT event is defined as: Primary forms a lower low (last low < previous low) Comparison forms a higher low (last low > previous low) If inverse correlation is enabled, the comparison condition flips to maintain logical confirmation rules The two primary swings must be within the configured bar distance window Optional minimum percentage difference must be satisfied A simple anti duplication rule prevents repeated triggers on the same structure These checks are implemented directly in the bullish detection block. 6. Bearish SMT Condition (HH vs LH) A bearish SMT event is defined as: Primary forms a higher high (last high > previous high) Comparison forms a lower high (last high < previous high) Inverse correlation flips the comparison rule Range checks, minimum difference filtering, and duplicate protection apply similarly These checks are implemented in the bearish detection block. 7. Percentage Difference Filter The optional “Min Price Diff (%)” filter measures the relative distance between the last two primary swing prices. This prevents very small structural changes from being treated as valid SMT signals. priceDiffPerc = math.abs(lastSwing.price - prevSwing.price) / prevSwing.price * 100.0 The divergence condition is only allowed to trigger if this value exceeds the user defined threshold. priceOk = priceDiffPerc >= minPriceDiff This filter is especially useful on higher timeframes or during low volatility conditions, where micro structure noise can otherwise produce misleading signals. 8. Visualization and Output When a divergence is confirmed, the script: Stores the event in a divergence array (limited by “Max Divergences to Display”) Draws a directional SMT label with a tooltip (optional) Draws connecting lines using time based coordinates for clean alignment (optional) It also updates an information table on the last bar only, and exposes alertconditions for automation workflows.
อินดิเคเตอร์ Pine Script®
โดย UnknownUnicorn113699460
2
cd_correlation_analys_Cxcd_correlation_analys_Cx General: This indicator is designed for correlation analysis by classifying stocks (487 in total) and indices (14 in total) traded on Borsa İstanbul (BIST) on a sectoral basis. Tradingview's sector classifications (20) have been strictly adhered to for sector grouping. Depending on user preference, the analysis can be performed within sectors, between sectors, or manually (single asset). Let me express my gratitude to the code author, @fikira, beforehand; you will find the reason for my thanks in the context. Details: First, let's briefly mention how this indicator could have been prepared using the classic method before going into details. Classically, assets could be divided into groups of forty (40), and the analysis could be performed using the built-in function: ta.correlation(source1, source2, length) → series float. I chose sectoral classification because I believe there would be a higher probability of assets moving together, rather than using fixed-number classes. In this case, 21 arrays were formed with the following number of elements: (3, 11, 21, 60, 29, 20, 12, 3, 31, 5, 10, 11, 6, 48, 73, 62, 16, 19, 13, 34 and indices (14)). However, you might have noticed that some arrays have more than 40 elements. This is exactly where @Fikira's indicator came to the rescue. When I examined their excellent indicator, I saw that it could process 120 assets in a single operation. (I believe this was the first limit overrun; thanks again.) It was amazing to see that data for 3 pairs could be called in a single request using a special method. You can find the details here: When I adapted it for BIST, I found it sufficient to call data for 2 pairs instead of 3 in a single go. Since asset prices are regular and have 2 decimal places, I used a fixed multiplier of $10^8$ and a fixed decimal count of 2 in Fikira's formulas. With this method, the (high, low, open, close) values became accessible for each asset. The summary up to this point is that instead of the ready-made formula + groups of 40, I used variable-sized groups and the method I will detail now. Correlation/harmony/co-movement between assets provides advantages to market participants. Coherent assets are expected to rise or fall simultaneously. Therefore, to convert co-movement into a mathematical value, I defined the possible movements of the current candle relative to the previous candle bar over a certain period (user-defined). These are: Up := high > high and low > low Down := high < high and low < low Inside := high <= high and low >= low Outside := high >= high and low <= low and NOT Inside. Ignore := high = low = open = close If both assets performed the same movement, 1 was added to the tracking counter. If (Up-Up), (Down-Down), (Inside-Inside), or (Outside-Outside), then counter := counter + 1. If the period length is 100 and the counter is 75, it means there is 75% co-movement. Corr = counter / period ($75/100$) Average = ta.sma(Corr, 100) is obtained. The highest coefficients recorded in the array are presented to the user in a table. From the user menu options, the user can choose to compare: • With assets in its own sector • With assets in the selected sector • By activating the confirmation box and manually entering a single asset for comparison. Table display options can be adjusted from the Settings tab. In the attached examples: Results for AKBNK stock from the Finance sector compared with GARAN stock from the same sector: Timeframe: Daily, Period: 50 => Harmony 76% (They performed the same movement in 38 out of 50 bars) Comment: Opposite movements at swing high and low levels may indicate a change in the direction of the price flow (SMT). Looking at ASELS from the Electronic Technology sector over the last 30 daily candles, they performed the same movements by 40% with XU100, 73.3% (22/30) with XUTEK (Technology Index), and 86.9% according to the averages. Comment: It is more appropriate to follow ASELS stock with XUTEK (Technology index) instead of the general index (XU100). Opposite movements at swing high and low levels may indicate a change in the direction of the price flow (SMT). Again, when ASELS stock is taken on H1 instead of daily, and the length is 100 instead of 30, the harmony rate is seen to be 87%. Please share your thoughts and criticisms regarding the indicator, which I prepared with a bit of an educational purpose specifically for BIST. Happy trading.
อินดิเคเตอร์ Pine Script®
โดย cdikici71
2
Multi Timeframe BOS & rBOSThis is the same Multi-Timeframe Break of Structure and Market Structure Shift posted by Lenny_Kiruthu. However, the only difference is the naming of Market Structure Shift to rBOS (Break of Structure Reverse). To me, they are all break of structures when previous peaks or valleys are violated. The only difference is in sequence. Once a sequence of BOS reverses, then a new sequence begins. To me, this simplifies the various terminology incorporated by different systems such as ICT or SMT which adds unnecessary complexity. eT
อินดิเคเตอร์ Pine Script®
โดย CheapTricks
2
cd_indiCATor_CxGeneral: This indicator is the redesigned, simplified, and feature-enhanced version of the previously shared indicators: cd_cisd_market_Cx, cd_HTF_Bias_Cx, cd_sweep&cisd_Cx, cd_SMT_Sweep_CISD_Cx, and cd_RSI_divergence_Cx. Within the holistic setup, the indicator tracks: • HTF bias • Market structure (trend) in the current timeframe • Divergence between selected pairs (SMT) • Divergence between price and RSI values • Whether the price is in an important area (FVG, iFVG, and Volume Imbalance) • Whether the price is at a key level • Whether the price is within a user-defined special timeframe The main condition and trigger of the setup is an HTF sweep with CISD confirmation on the aligned timeframe. When the main condition occurs, the indicator provides the user with a real-time market status summary, enriched with other data. ________________________________________ What’s new? -In the SMT module: • Triad SMT analysis (e.g.: NQ1!, ES1!, and YM1!) • Dyad SMT analysis (e.g.: EURUSD, GBPUSD) • Alternative pair definition and divergence analysis for non-correlated assets o For crypto assets (xxxUSDT <--> xxxUSDT.P) (e.g.: SOLUSDT.P, SOLUSDT) o For stocks, divergence analysis by comparing the asset with its value in another currency (BIST:xxx <--> BIST:xxx / EURTRY), (BAT:xxx <--> BAT:xxx / EURUSD) -Special timeframe definition -Configurable multi-option alarm center -Alternative summary presentation (check list / status table / stickers) ________________________________________ Details and usage: The user needs to configure four main sections: • Pair and correlated pairs • Timeframes (Auto / Manual) • Alarm center • Visual arrangement and selections Pair Selections: The user should adjust trading pairs according to their trade preferences. Examples: • Triad: NQ1!-ES1!-YM1!, BTC-ETH-Total3 • Dyad: NAS100-US500, XAUUSD-XAGUSD, XRPUSDT-XLMUSDT Single pairs: -Crypto Assets: If crypto assets are not in the triad or dyad list, they are automatically matched as: Perpetual <--> Spot (e.g.: DOGEUSDT.P <--> DOGEUSDT) If the asset is already defined in a dyad list (e.g., DOGE – SHIB), the dyad definition takes priority. ________________________________________ -Stocks: If stocks are defined in the dyad list (e.g.: BIST:THYAO <--> BIST:PGSUS), the dyad definition takes priority. If not defined, the stock is compared with its value in the selected currency. For example, in the Turkish Stock Exchange: BIST:FENER stock, if EUR is chosen from the menu, is compared as BIST:FENER / OANDA:EURTRY. Here, “OANDA” and the stock market currency (TRY) are automatically applied for the exchange rate. For NYSE:XOM, its pair will be NYSE:XOM / EURUSD. ________________________________________ Timeframes: By default, the menu is set to “Auto.” In this mode, aligned timeframes are automatically selected. Aligned timeframes (LTF-HTF): 1m-15m, 3m-30m, 5m-1h, 15m-4h, 1h-D, 4h-W, D-M Example: if monitoring the chart on 5m: • 1h sweep + 5m CISD confirmation • D sweep + 1h CISD confirmation (bias) • 5m market structure • 1h SMT and 1h RSI divergence analysis For manual selections, the user must define the timeframes for Sweep and HTF bias. FVG, iFVG, and Volume Imbalance timeframes must be manually set in both modes. ________________________________________ Alarm Center: The user can choose according to preferred criteria. Each row has options. “Yes” → included in alarm condition. “No” → not included in alarm condition. If special timeframe criteria are added to the alarm, the hour range must also be entered in the same row, and the “Special Zone” tab (default: -4) should be checked. Key level timeframes and plot options must be set manually. Example alarm setup: Alongside the main Sweep + CISD condition, if we also want HTF bias + Trend alignment + key level (W, D) and special timeframe (09:00–11:00), we should set up the menu as follows: ________________________________________ Visual Arrangement and Selections: Users can control visibility with checkboxes according to their preferences. In the Table & Sticker tab, table options and labels can be controlled. • Summary Table has two options: Check list and Status Table • From the HTF bias section, real-time bias and HTF sweep zone (optional) are displayed • The RSI divergence section only shows divergence analysis results • The SMT 2 sub-section only functions when triad is selected Labels are shown on the bar where the sweep + CISD condition occurs, displaying the current situation. With the Check box option, all criteria’s real-time status is shown (True/False). Status Table provides a real-time summary table. Although the menu may look crowded, most settings only need to be adjusted once during initial use. ________________________________________ What’s next? • Suggestions from users • Standard deviation projection • Mitigation/order blocks (cd special mtg) • PSP /TPD ________________________________________ Final note: Every additional criterion in the alarm settings will affect alarm frequency. Multiple conditions occurring at the same time is not, by itself, sufficient to enter a trade—you should always apply your own judgment. Looking forward to your feedback and suggestions. Happy trading! 🎉
อินดิเคเตอร์ Pine Script®
โดย cdikici71
114
SMT (DXY) DIVERGENCESThis indicator detects Smart Money Technique (SMT) Divergences between the chart symbol and up to two comparison symbols defined in the settings. It identifies swing highs and swing lows on correlated/uncorrelated instruments, compares their highs and lows, and determines possible divergences. 🔷 What It Detects -Bullish SMT Divergence: When the lows of the chart symbol slope in the opposite direction of the comparison symbol’s lows. -Bearish SMT Divergence: When the highs of the chart symbol slope in the opposite direction of the comparison symbol’s highs. -Multi-Symbol Compatibility: Ability to compare the main symbol with one or two external tickers (default: DXY and GBPUSD). -Negative Divergence Option: The inversion feature allows comparison with opposite-moving charts. 🔷 Calculation Logic -Swing Detection: Swing highs and lows are confirmed using pivot-based logic. -Comparison: Slopes of highs and lows are calculated for both the chart symbol and the comparison symbols. -Divergence Identification: If slopes point in opposite directions, an SMT divergence (bullish or bearish) is marked. -Visualization: Lines and labels (“+ SMT” or “– SMT”) are drawn on the chart. Historical lines can be kept or cleared depending on user settings. 🔷 Visual Bearish SMT: Downward line with “– SMT” label. Bullish SMT: Upward line with “+ SMT” label. Style Options: Predefined color schemes (TLAB, standard, monochrome) or fully customizable colors. Line Style: Solid, dashed, or dotted. 🔷 Customization Options -Show Historical: Decide whether past divergences remain visible on the chart. -Comparison Symbols: Define up to two external tickers, with optional inversion. -Swing Lengths: Preconfigured pivot lengths automatically adapt to the selected timeframe (Daily, 4H, 1H, 5m/15m). -Lines & Labels: Enable or disable bullish/bearish SMT divergences and their annotations. 🔷 Indicator Usage Select the comparison symbol with positive or negative correlation. Wait for the “+ SMT” or “– SMT” marker to appear on the chart. Divergences can be used as contextual confluence when studying potential market shifts: A + SMT marker may suggest bullish divergence. A – SMT marker may suggest bearish divergence.
อินดิเคเตอร์ Pine Script®
โดย Algoryze
11
cd_SMT_Sweep_CISD_CxGeneral This indicator is designed to show trading opportunities after sweeps of higher timeframe (HTF) highs/lows and, if available, Smart Money Technique (SMT) divergence with a correlated asset, followed by confirmation from a lower timeframe change in state delivery (CISD). Users can track SMT, Sweep, and CISD levels across nine different timeframes. ________________________________________ Usage and Details Commonly correlated timeframes are available in the menu by default. Users can also enter other compatible timeframes manually if necessary. The indicator output is presented as: • A summary table • Display on HTF candles • CISD levels shown as lines Users can disable any of these from the menu. Presentations of selected timeframes are displayed only if they are greater than or equal to the active chart timeframe. From the Show/Hide section, you can control the display of: • SMT table • Sweep table • HTF candles • CISD levels • HTF boxes aligned with the active timeframe ________________________________________ SMT Analysis To receive analysis, users must enter correlated assets in the menu (or adjust them as needed). If asset X is paired with correlated asset Y, then a separate entry for Y correlated with X is not required. Four correlation pairs are included by default. Users should check them according to their broker/exchange or define new ones. Checkboxes at the beginning of each row allow activation/deactivation of pairs. SMT analysis is performed on the last three candles of each selected HTF. If one asset makes a new high while the correlated one does not (or one makes a new low while the other does not), this is considered SMT and will be displayed both in the table and on the chart. Charts without defined correlated assets will not display an SMT table. ________________________________________ Sweep Analysis For the selected timeframes, the current candle is compared with the previous one. If price violates the previous level and then pulls back behind it, this is considered a sweep. It is displayed in both the table and on the chart. Within correlated pairs, the analysis is done separately and shown only in the table. Example with correlated and non-correlated pairs: • In the table, X = false, ✓ = true. • The Sweep Table has two columns for Bullish and Bearish results. • For correlated pairs, both values appear side by side. • For undefined pairs, only the active asset is shown. Example 1: EURUSD and GBPUSD pair • If both sweep → ✓ ✓ • If one sweeps, the other does not → ✓ X • If neither sweeps → X X Example 2: AUDUSD with no correlated pair defined • If sweep → ✓ • If no sweep → X ________________________________________ HTF Candles For every HTF enabled by the user, the last three candles (including the current one) are shown on the chart. SMT and sweep signals are marked where applicable. ________________________________________ CISD Levels For the selected timeframes, bullish and bearish CISD levels are plotted on the chart. ________________________________________ HTF Boxes HTF boxes aligned with the active timeframe are displayed on the chart. Box border colors change according to whether the active HTF candle is bullish or bearish. ________________________________________ How to Read the Chart? Let’s break down the example below: • Active asset: Nasdaq • Correlated asset: US500 (defined in the menu, confirmed in the table bottom row) • Active timeframe: H1 → therefore, the HTF box is shown for Daily • Since a correlated pair is defined, the indicator runs both SMT and Sweep analysis for the selected timeframes. Without correlation, only Sweep analysis would be shown. Table is prepared for H1 and higher timeframes (as per user selection and active TF). Observations: • SMT side → H1 timeframe shows a bearish warning • Sweep side → Bearish column shows X and ✓ o X → no sweep on Nasdaq o ✓ → sweep on US500 Meaning: US500 made a new high (+ sweep) while Nasdaq did not → SMT formed. The last column of the table shows the compatible LTF for confirmation. For H1, it suggests checking the 5m timeframe. On the chart: • CISD levels for selected timeframes are drawn • SMT line is marked on H1 candles • Next step: move to 5m chart for CISD confirmation before trading (with other confluences). Similarly, the Daily row in the table shows a Bullish Sweep on US500. ________________________________________ Alerts Two alert options are available: 1. Activate Alert (SMT + Sweep): Triggers if both SMT and Sweep occur in the selected timeframes. (Classic option) 2. Activate Alert (Sweep + Sweep): Triggers if sweeps occur in both assets of a correlated pair at the same timeframe. Interpretation: If SMT + Sweep are already present on higher timeframes, and simultaneous sweeps appear on lower timeframes, this may indicate a strong directional move. Of course, this must be validated with CISD and other confluences. ________________________________________ HTF CISD Levels Although CISD levels act as confirmation levels in their own timeframe, observing how price reacts to HTF CISD levels can provide valuable insights for intraday analysis. POIs overlapping with these levels may be higher priority. ________________________________________ What’s Next in Future Versions? • Completed CISD confirmations • Additional alert options • Plus your feedback and suggestions ________________________________________ Final Note I’ll be happy to hear your opinions and feedback. Happy trading!
อินดิเคเตอร์ Pine Script®
โดย cdikici71
25
20/40/60Displays three consecutive, connected range boxes showing high/low price ranges for customizable periods. Boxes are positioned seamlessly with shared boundaries for continuous price action visualization. Features Three Connected Boxes: Red (most recent), Orange (middle), Green (earliest) periods Customizable Positioning: Set range length and starting offset from current bar Individual Styling: Custom colors, transparency, and border width for each box Display Controls: Toggle borders, fills, and line visibility Use Cases Range Analysis: Compare volatility across time periods, spot breakouts Support/Resistance: Use box boundaries as potential S/R levels Market Structure: Visualize recent price development and trend patterns Key Settings Range Length: Bars per box (default: 20) Starting Offset: Bars back from current to position boxes (default: 0) Style Options: Colors, borders, and visibility controls for each box Perfect for traders analyzing consecutive price ranges and comparing current conditions to recent historical periods.
อินดิเคเตอร์ Pine Script®
โดย mvxt