✅ Market Maker Levels (v6 Labels + Prices, No Zones)this shows previous day and weeks high n low which helps in managing the trades to find support and resistance
Penunjuk dan strategi
Williams AD + MA“I’ve added an MA to the Williams Accumulation/Distribution (AD) indicator. You can use it to infer potential trend inflection points and to assess the persistence of the trend.”
CDC BACKTEST (MACD) FIX AMOUNT $200k per trade This strategy implements an Exponential Moving Average (EMA) Crossover System designed for backtesting and performance evaluation. EMA 12,26 (MACD)
The trading logic is based on the crossover between two EMAs — a short-term EMA (12) and a long-term EMA (26) — which serves as a momentum-based signal for trend identification.
Buy Condition:
A long (buy) position is entered when the 12-period EMA crosses above the 26-period EMA, indicating a potential upward trend or bullish momentum.
Sell Condition:
A position is closed, or a short (sell) position is opened, when the 12-period EMA crosses below the 26-period EMA, signaling a potential downward trend or bearish momentum.
Position Sizing:
Each trade with a fixed position size of 200,000 USD (default), while the starting account balance is set at 400,000 (USD).
Both the fixed trade amount and the initial balance are user-adjustable parameters, allowing flexibility for different risk preferences and portfolio sizes.
ORB + Liquidity Sweeps**Title:** ORB + Liquidity Sweeps
**Description:**
The **“ORB + Liquidity Sweeps”** indicator combines the *Opening Range Breakout (ORB)* model with dynamic *liquidity sweep detection* to identify high-probability reversal or continuation setups during key session periods. This script visually maps where price sweeps liquidity at highs/lows and tracks how those sweeps interact with the defined ORB range — offering clear, data-driven confluence zones for professional intraday execution.
---
### 🔹 FEATURES OVERVIEW
**1. Liquidity Sweeps **
* Detects **bullish** and **bearish liquidity grabs** using swing highs/lows based on user-defined pivot length.
* Supports three detection modes:
* **Only Wicks:** Marks when price pierces a level with a wick and rejects.
* **Only Outbreaks & Retest:** Confirms full breaks and retests.
* **Wicks + Outbreaks & Retest:** Combines both behaviors for full context.
* Automatically shades sweep zones and extends them until price mitigates or breaks through.
* Visuals:
* 🟩 **Bullish sweeps** = green wick/zone
* 🟥 **Bearish sweeps** = red wick/zone
* Configurable color transparency, max bar extension, and style options.
* Generates real-time **alerts** for each sweep:
* `🔼 Bullish Wick Sweep detected`
* `🔽 Bearish Wick Sweep detected`
---
**2. Opening Range Breakout (ORB)**
* Automatically defines the **Opening Range** using a customizable session window (default: *09:30–09:45 EST*).
* Tracks **ORB High** and **ORB Low** in real time.
* Displays the range only on intraday charts within the selected time window.
* Sends breakout alerts:
* `ORB Breakout Up` → Price crosses above ORB high.
* `ORB Breakout Down` → Price crosses below ORB low.
* Ideal for identifying initial volatility expansion zones and potential directional bias for the session.
---
**3. ORB–Liquidity Sweep Interaction**
* Highlights when **liquidity sweep zones overlap or touch the ORB range**, signaling a high-interest confluence zone.
* Issues alerts when interaction occurs:
* `Bull Sweep interacts with ORB`
* `Bear Sweep interacts with ORB`
* Useful for traders looking to align **liquidity events with session structure** to time entries.
---
**4. Built-in Alert System**
All alerts are pre-configured and can be activated directly from the TradingView “Add Alert” menu:
* **Bullish Wick Sweep**
* **Bearish Wick Sweep**
* **ORB Breakout Up**
* **ORB Breakout Down**
* **Bull Sweep interacts with ORB**
* **Bear Sweep interacts with ORB**
---
### ⚙️ HOW TO USE
1. **Add to Chart:** Apply on any intraday timeframe (preferably 1–15 min).
2. **Configure ORB Window:** Set the session start and duration (e.g., `09:30–09:45`options , 08:30 -08:45 futures ) for your trading region.
3. **Select Sweep Mode:** Choose from “Only Wicks,” “Only Outbreaks & Retest,” or “Wicks + Outbreaks & Retest.”
4. **Watch for Confluence:**
* A **sweep near ORB levels** often signals exhaustion or potential reversal.
* A **breakout through ORB following a sweep** suggests momentum continuation.
5. **Set Alerts:** Enable relevant alerts for automatic notifications when sweeps or ORB breaks occur.
---
### 📊 TRADING APPLICATIONS
* Identify **stop hunts** and **liquidity grabs** around ORB levels.
* Combine with volume, delta, or order flow indicators for confirmation.
* Use confluence zones (Sweep + ORB overlap) as **entry or take-profit** points.
* Excellent for **index futures**, **forex**, and **high-volume equities** during the opening session.
---
**Developed by:** SB
**Category:** Price Action / Liquidity / Session Structure
**Compatible Timeframes:** Intraday (1m–5m recommended)
**Alerts Included:** ✅
**Overlay:** Yes
**Version:** v6
---
*This tool is designed for advanced price-action traders who study liquidity behavior, ORB structure, and intraday expansion patterns.*
0DTE Options - Iron Condor & ButterflyTo help options traders:
Plan and structure Iron Condor or Butterfly spreads in “Setup Mode.”
Track live trades, including P&L, breach risk, and strike distances, in “Live Mode.”
Visualize the trade on the price chart with profit zones, breakeven lines, strike markers, and alerts.
Evaluate market conditions using IV Rank, ATR-based range modeling, and modeled Delta approximation.
Essentially, it turns your TradingView chart into an options risk graph + planning terminal.
⚙️ Core Modes of Operation
🧱 1. Setup Mode
Used for planning new trades. It automatically suggests strikes based on:
ATR (volatility proxy)
IV Rank
Target Delta
Chosen risk tier (High / Mid / Low / Delta)
You can:
Preview recommended short and long strikes.
See estimated credit, width, and risk/reward ratios in a setup table.
Auto-feed these calculated strikes into the Live Mode to track them later.
Example Use:
Before market open, choose Setup Mode → Mid Risk Tier → see what strike widths and credits make sense for the day.
📈 2. Live Mode
Used to track real trades you’ve already opened.
You can:
Paste your real trade data (strikes, credits, etc.) into the 📋 paste field.
Or auto-feed from Setup Mode (if “Auto-Feed” is enabled).
The indicator then plots:
Short/long strikes
Breakevens
Profit/loss zone
Real-time breach detection and delta drift
Alerts when price nears your strikes or exits your safe zone.
Example Use:
After opening an Iron Condor on SPX, paste in 626,628,620,618,1.20,1, and the chart visually shows your safe range and warning zones.
🧮 Built-In Calculations
1. IV Rank (Volatility Environment)
Uses a 20-day log return volatility model to calculate IV Rank (percentile of volatility over the last 252 bars).
You can use this automatically or manually override it if you have data from your broker.
→ High IV Rank (>50) = better for selling Iron Condors (more premium).
2. ATR (Average True Range)
Measures short-term volatility to estimate expected daily price movement.
Used in Setup Mode to model distance between strikes.
3. Strike Calculations (Setup Mode)
Based on risk tier:
High Risk → wide wings, high credit, high potential drawdown
Mid Risk → balanced setup
Low Risk → narrow wings, safer but less credit
Delta Mode → based purely on target delta (e.g., 0.20)
Uses ATR × multiplier to determine how far short strikes should be from current price.
4. Credit Estimation
Based on strike width × IV Rank multiplier:
IV > 50 → 30% of width
IV 30–50 → 25%
IV < 30 → 20%
5. Profit & Loss Modeling
The indicator computes:
Max Profit:
Iron Condor → credit × 100 × contracts
Butterfly → (wing width − debit) × 100 × contracts
Max Loss:
Iron Condor → width − credit
Butterfly → debit × 100 × contracts
Breakevens:
Iron Condor → short strikes ± credit
Butterfly → body ± debit
Current P&L: Approximated by where the underlying is relative to the short/long strikes.
6. Delta Modeling
Estimates each short strike’s modeled delta based on how far it is from current price.
Displays total delta balance to show directional bias.
If Delta drifts too high → market imbalance → consider rolling or adjusting.
7. Breach Detection System
Automatically classifies your trade as:
🟢 In Range: Price between short strikes (safe zone).
🟠 Near Breach: Price close to short strike (risk zone).
🔴 Breached: Price outside long strike (stop or adjust zone).
This dynamically changes color in your profit box and info label.
🎨 Visual Components
Element Meaning Color
Red Line Put side strikes 🔻 Red
Green Line Call side strikes 🔺 Green
Yellow Dotted Lines Breakevens 🟡 Yellow
Green Box Profit zone 🟩 Light green
Orange Box Adjustment zone (near breach) 🟧 Orange
Red Box Breach zone 🟥 Red
White Line Current price ⚪ White
Optional labels display strike details and distances (e.g., “📉 Short Put: 620 – 5 pts away”).
📊 Setup Table (Setup Mode Only)
Displays a grid comparing all risk tiers:
Tier Short Call Short Put Width Est. Credit R:R
High 632 614 4.0 $1.20 0.43
Mid 630 616 3.0 $0.90 0.43
Low 628 618 2.0 $0.60 0.43
Highlighted row = selected risk tier.
This lets you compare how wide/narrow each setup is before committing to a trade.
🧾 Info Box (Live Mode)
Displays real-time stats such as:
🔶 IRON CONDOR | 1 Contract
📊 Calls: 626 / 628 | Puts: 620 / 618
💵 Credit: $1.20 | 💰 Profit: $120 | 🔴 Loss: $180
⬆️ BE: 627.2 | ⬇️ BE: 618.8
📍 Current: $623 | 💵 P&L: +$35.00 (+29.1%)
📏 To Short Call: 3 | To Short Put: 3
📊 Delta: 0.05 | IV Rank: 56% (FAVORABLE)
🔴 BREACH STATUS: In Range
🚨 Alerts
The indicator generates TradingView alerts for:
⚠️ Approaching Call Zone → nearing short call
⚠️ Approaching Put Zone → nearing short put
🛑 Stop Loss Triggered → current P&L exceeds loss threshold
🟠 Near Breach → price entering adjustment zone
🔴 Breached → price outside protection (long strikes)
These alerts can be used with TradingView notifications or webhooks.
🧠 How to Use It Step-by-Step
A. Planning (Setup Mode)
Set mode to “Setup.”
Adjust:
Risk Tier (High / Mid / Low / Delta)
Target Delta (0.15–0.30 recommended)
Strike Interval (e.g., 1.0 or 5.0)
Check Setup Table → see suggested strikes & credits.
Optionally toggle Auto-Feed → Live to send to live mode later.
B. Executing (Broker)
Confirm and enter your trade in your brokerage (use the strikes shown).
Record your strikes, net credit/debit, and number of contracts.
C. Tracking (Live Mode)
Switch to “Live” mode.
Paste your strikes in the 📋 Paste Data field:
Iron Condor Example: 626,628,620,618,1.20,1
Butterfly Example: 600,620,640,2.50,2
The chart updates:
Lines = your strikes
Boxes = profit/risk zones
Labels = strike info, distance to price
Info box = P&L, delta, IV rank, breach status
Set alerts for automatic notifications.
D. Managing the Trade
When the chart turns orange or red, you’re approaching or breaching a strike.
Use this signal to roll, hedge, or close your trade.
Monitor Gamma Risk: warning appears when price nears short strikes (explosive delta risk).
📌 Summary
Feature Description
Mode Switching Plan (Setup) or Track (Live)
IV Rank & ATR Modeling Estimates volatility environment
Auto Strike Planning Suggests strikes based on risk/delta
Visual Range Map Profit, breakeven, and adjustment zones
Real-Time Alerts Warns when nearing or breaching strikes
Trade Info Box Displays live risk, reward, delta, IV, and P&L
Setup Table Compares setups across risk tiers
Fully Configurable Works for Iron Condors or Butterflies
MACD Remastered [CHE]MACD Remastered — Robust MACD with confirmed pivot-based divergence, optional signal bands, and ready-to-use alerts.
Summary
This indicator augments classic MACD with a robust, confirmed pivot-based divergence engine and an optional signal channel using Bollinger Bands. Divergence signals are only produced after a pivot is confirmed, which reduces noise from transient swings. A line-of-sight clearance check filters cases where the MACD histogram path contradicts the divergence, further cutting false flags. Histogram coloring clarifies momentum changes, while optional triangles project the same signals onto the main chart for quick context.
Motivation: Why this design?
Standard MACD divergence tools tend to fire early in volatile phases and flip during consolidation. The core idea here is to delay decision points until a pivot is confirmed and to validate the path between pivots. This addresses fake flips and improves signal credibility at the cost of some latency. Optional bands around the Signal line add context about compression and expansion without altering MACD’s core behavior.
What’s different vs. standard approaches?
Reference baseline: Classical MACD (fast and slow moving averages, Signal line, histogram) with simple divergence checks.
Architecture differences:
Confirmed pivot logic with left and right bars.
Line-of-sight clearance test across the histogram path between pivots.
Optional Signal-line Bollinger Bands with configurable length and width.
Composite “Any Divergence” alert plus separate regular and hidden alerts.
Optional main-chart triangles using forced overlay for at-a-glance context.
Practical effect: Fewer early or contradictory divergence signals, clearer momentum context via histogram colors and a visible Signal channel during compression and expansion.
How it works (technical)
The MACD line derives from a fast and a slow moving average on a chosen source. The Signal line smooths the MACD line using a selected moving average type and length. The histogram is the difference between MACD and Signal and is colored by direction and acceleration.
Divergence uses confirmed pivots: a pivot forms only after a set number of bars on the right side, so the event is locked in. The engine retrieves the last two relevant pivots and checks price movement versus the MACD histogram movement to classify regular or hidden divergence. A line-of-sight clearance routine traverses the histogram path between the two pivots and rejects the signal if the path invalidates the directional relationship. When enabled, Bollinger Bands are plotted around the Signal line; width scales with standard deviation. Programmatic alerts fire only on confirmed bars. No higher-timeframe requests are used.
Parameter Guide
Oscillator MA Type — Sets fast and slow MA family for MACD. Default: EMA. Tip: EMA is more responsive; SMA is steadier.
Fast Length — Fast MA period. Default: 12. Trade-off: Shorter is quicker but noisier.
Slow Length — Slow MA period. Default: 26. Trade-off: Longer reduces noise but adds lag.
Source — Price input. Default: Close. Tip: Use a stable source for consistency.
Signal MA Type — Moving average family for Signal. Default: EMA.
Signal Length — Smoothing of MACD into Signal. Default: 9. Trade-off: Longer smooths more, reacts slower.
Calculate Divergence — Enables divergence engine. Default: True.
Enable Bollinger Bands on Signal — Adds bands around Signal. Default: False.
BB Length — Sampling window for bands. Default: 20. Active: Only when bands are enabled.
BB StdDev — Band width in standard deviations. Default: 2.0. Bounds: between about zero point zero zero one and fifty.
Pivot Left / Pivot Right — Bars to the left and right that define a confirmed pivot. Default: five and five. Trade-off: Larger values mean stronger but slower pivots.
Min / Max Bars Between Pivots — Valid window between two pivots. Default: five and sixty. Tip: Increase minimum to reduce micro-divergences.
Detect Hidden — Include hidden divergence. Default: True.
Draw Lines — Draw connector lines on the MACD pane. Default: True.
Alerts: Enable / Regular / Hidden / Frequency / Prefix — Control alert emission, categories, cadence, and label. Defaults: Enabled, both categories on, once per bar close, prefix “MACD RM”.
Reading & Interpretation
Histogram: Columns above zero reflect positive momentum; below zero reflect negative momentum. Color shifts indicate momentum increasing or decreasing within each side.
MACD and Signal: Crosses and distance indicate momentum shifts and strength. When bands are enabled, touches and departures hint at compression and expansion around the Signal.
Divergence: Solid green lines and labels indicate regular bullish; solid red indicate regular bearish. Dashed teal and dashed orange denote hidden bullish and hidden bearish. Triangles on the main chart mirror these events for quicker visibility.
Practical Workflows & Combinations
Trend following: Use histogram color transitions with a structure filter such as higher highs and higher lows for long bias, or lower highs and lower lows for short bias. Divergence against the prevailing structure suggests caution or partial exits.
Exits and risk: In a long, regular bearish divergence near resistance can justify scaling out or tightening stops. Hidden divergence in the trend direction can support continuation but should not replace risk controls.
Multi-asset / Multi-timeframe: Works across liquid futures, forex, indices, and large-cap equities. Start with defaults on four-hour and daily; shorten lengths on intraday only when liquidity is strong.
Behavior, Constraints & Performance
Repaint and confirmation: Signals are anchored only after the right-side pivot bars complete; alerts trigger on confirmed bars. This intentionally adds latency to reduce noise.
No higher-timeframe requests: No `security` calls are used; repaint risk is primarily tied to live bars before confirmation.
Resources: Declared `max_bars_back` is five hundred. The divergence path check iterates between pivots, bounded by the maximum bars parameter. Line objects may accumulate; limits are set for lines and labels.
Known limits: Latency at sharp turns, potential misses during fast single-bar reversals, and sensitivity to extremely choppy sessions if minimum gap between pivots is set too low.
Sensible Defaults & Quick Tunin g
Starting point: EMA, twelve and twenty-six with Signal nine; pivots five and five; minimum five, maximum sixty; alerts on close; bands off.
Too many flips: Increase Signal length, raise pivot counts, and increase minimum bars between pivots. Consider disabling hidden divergence.
Too sluggish: Reduce pivot counts, lower Signal length, and enable bands to visualize early compression.
Cluttered chart: Keep lines off and rely on labels and main-chart triangles. Use the alert prefix to route events cleanly.
What this indicator is—and isn’t
This is a visualization and signal layer for MACD with confirmed, path-checked divergence and optional Signal bands. It is not a trading system, not predictive, and not a position management framework. Use it together with structure analysis, liquidity context, and explicit risk controls.
Disclaimer
The content provided, including all code and materials, is strictly for educational and informational purposes only. It is not intended as, and should not be interpreted as, financial advice, a recommendation to buy or sell any financial instrument, or an offer of any financial product or service. All strategies, tools, and examples discussed are provided for illustrative purposes to demonstrate coding techniques and the functionality of Pine Script within a trading context.
Any results from strategies or tools provided are hypothetical, and past performance is not indicative of future results. Trading and investing involve high risk, including the potential loss of principal, and may not be suitable for all individuals. Before making any trading decisions, please consult with a qualified financial professional to understand the risks involved.
By using this script, you acknowledge and agree that any trading decisions are made solely at your discretion and risk.
Do not use this indicator on Heikin-Ashi, Renko, Kagi, Point-and-Figure, or Range charts, as these chart types can produce unrealistic results for signal markers and alerts.
Best regards and happy trading
Chervolino
X Tail that Wagsintraday session-framework and ETH-anchored VWAP tool for TradingView. It draws today’s OVN (ETH) high/mid/low, today’s RTH-day open, previous day open/high/low, and a carried ETH VWAP handle (yesterday’s 4:00 PM NY VWAP, projected forward) to give you a clean, non-repainting scaffold for bias, structure, and execution. All timestamps are New York–local with DST handled explicitly, so historical sessions align correctly across time changes.
Key Capabilities
ETH OVN Range (18:00 → 09:30 NY)
Captures the rolling overnight high/low and computes the mid; at 09:30 NY it locks those levels and extends them to 16:00 NY (same day).
Optional labels (size/color configurable) placed slightly to the right of the 4 PM timestamp for readability.
Daily Handles (Today & Previous Day)
Today’s open line starts at the ETH open (anchor preserved) and extends toward 4 PM NY (or up to the “current bar + 5 bars” cap), with label control.
Previous day open/high/low plotted as discrete reference lines for carry-over structure.
ETH-Anchored VWAP (Live) + Bands
ETH-anchored VWAP runs only during the active ETH session (DST-aware).
Optional VWAP bands (0.5×, 1.0×, 2.0× multipliers) plotted as line-break series.
Carried ETH VWAP Handle (PD 4 PM Snapshot)
At 16:00 NY, the script snapshots the final ETH VWAP value.
On the next ETH open, it projects that value as a static dashed line through the session (non-mutating, non-repainting), with optional label.
Labeling & Styling
Single-toggle label system with color and five sizes.
Per-line color/width controls for quick visual hierarchy.
Internal “tail” logic keeps right endpoints near price (open-anchored lines extend to min(4 PM, now + 5 bars)), avoiding chart-wide overdraw.
Robust Session Logic
All session boundaries computed in NY local time; DST rules applied for historical bars.
Cross-midnight windows handled safely (no gaps or misalignment around day rolls).
Primary Use Cases
Session Bias & Context
Use OVN H/M/L and today’s open to define structural bias zones before RTH begins. A break-and-hold above OVN mid, for example, can filter long ideas; conversely, rejection at OVN high can warn of mean reversion.
Carry-Forward Mean/Value Reference
The carried ETH VWAP (PD 4 PM) acts as a “value memory” line for the next day. Traders can:
Fade tests away from it in balanced conditions,
Use it as a pullback/acceptance gauge during trends,
Track liquidity grabs when price spikes through and reclaims.
Execution Planning & Risk
Anchor stops/targets around PD H/L and OVN H/M/L for well-defined invalidation.
Combine with your entry model (order-flow, momentum, or pattern) to time fades at range extremes or momentum breaks from OVN mid.
Confluence Mapping
Layer the tool with opening range tools, HTF zones, or profile/VWAPs (weekly/daily) to spot high-quality confluence where multiple references cluster.
Regime & Day-Type Read
Quickly see whether RTH accepts/rejects the OVN range or gravitates to PD VWAP handle, helping classify the day (trend, balanced, double-distribution, etc.).
Quick Start
Apply to your intraday chart (any instrument supported by TradingView; best on ≤15m for live intraday context).
In Current Day group, keep Open and OVN HL on; optionally display the mid.
In Previous Day group, enable PD Open/HL for carry-over levels.
Enable AVWAP if you want live ETH-anchored VWAP and its Bands for distance context.
Keep PD VWAP on to project yesterday’s 4 PM ETH VWAP as a static dashed line into today.
Use the Label group to size/color the on-chart tags.
Settings Overview (Plain-English)
Label: Toggle labels on/off; choose label text color and size.
Current Day:
Open (color/width) — daily open line anchored at ETH open.
OVN HL (and Mid) — overnight high/low and midpoint, locked at 09:30 and extended to 16:00.
AVWAP + Bands — ETH-anchored VWAP with optional 0.5×/1×/2× bands.
Previous Day:
PD Open/HL — yesterday’s daily handles.
PD VWAP — the carried snapshot of yesterday’s 4 PM ETH VWAP projected forward (dashed).
Notes & Best Practices
Time Zone: All session logic is hard-coded to America/New_York and DST-robust. No manual DST tweaks required.
Non-Repainting: The carried PD VWAP line is a snapshot; once drawn, it does not back-fill or mutate.
Intraday Use: Designed for intraday execution. It will display on higher TFs, but the session granularity is most informative at ≤15m.
Performance: Script caps lines/labels (500) and uses short “tails” to keep charts responsive.
Compatibility: Uses request.security(..., "D", series, lookahead_on) intentionally to lock daily handles early for planning; this is by design.
Typical Playbook Examples
Fade Extremes in Balance: As RTH opens inside OVN, look for rejection wicks at OVN High with confluence from PD VWAP handle overhead; risk above OVN High.
Trend Continuation: In directional sessions, acceptances above OVN Mid with price pulling back to the live ETH VWAP can offer continuation entries.
Reversion to Value: Sharp extensions away from the carried PD VWAP that quickly stall often revert to that handle; use it as a target or as an acceptance test.
MCL RSI Conflux v2.5 — Multi-Timeframe Momentum & Z-Score Full Description
Overview
The MCL RSI Conflux v2.5 is a multi-timeframe momentum model that integrates daily, weekly, and monthly RSI values into a unified composite. It extends the classical RSI framework with adaptive overbought/oversold thresholds and statistical normalization (Z-score confluence).
This combination allows traders to visualize cross-timeframe alignment, identify synchronized momentum shifts, and detect exhaustion zones with higher statistical confidence.
Methodology
The script extracts RSI data from three major time horizons:
Daily RSI (short-term momentum)
Weekly RSI (intermediate trend)
Monthly RSI (macro bias)
Each RSI is optionally smoothed, weighted, and aggregated into a Composite RSI.
A Z-score transformation then measures how far each RSI deviates from its historical mean, revealing when momentum strength is statistically extreme or aligned across timeframes.
Key Features
Multi-Timeframe RSI Engine – Computes RSI across D/W/M intervals with individual weighting controls.
Adaptive Overbought/Oversold Bands – Automatically adjusts OB/OS thresholds based on rolling volatility (standard deviation of daily RSI).
Composite RSI Score – Weighted consensus RSI that represents total market momentum.
Z-Score Confluence Analysis – Identifies when all three timeframes are statistically synchronized.
Z-Composite Histogram – Displays aggregated Z-score strength around the midline (50).
Divergence Detection – Flags confirmed pivot-based bull and bear divergences on the daily RSI.
Dynamic Gradient Background – Shifts from red to green based on composite momentum regime.
Customizable Control Panel – Displays RSI values, Z-scores, state, and adaptive bands for each timeframe.
Integrated Alerts – For crossovers, risk-on/off thresholds, alignment, and Z-confluence events.
Interpretation
All RSI values above 50: multi-timeframe bullish alignment.
All RSI values below 50: multi-timeframe bearish alignment.
Composite RSI > 60: risk-on environment; momentum expansion.
Composite RSI < 45: risk-off environment; momentum contraction.
Adaptive OB/OS hits: potential exhaustion or mean reversion setup.
Green Z-ribbon: all Z-scores positive and aligned (statistical confirmation).
Red Z-ribbon: all Z-scores negative and aligned (broad market weakness).
Divergences: short-term warning signals against the prevailing momentum bias.
Practical Application
Use the Composite RSI as a global momentum gauge for position bias.
Trade only in the direction of higher-timeframe alignment (avoid countertrend RSI).
Combine Z-ribbon confirmation with Composite RSI crosses to filter noise.
Use divergence labels and adaptive thresholds for risk reduction or exit timing.
Ideal for swing traders and macro momentum models seeking trend synchronization filters.
Recommended Settings
Market Mode k-Band Lookback Use Case
Stocks / ETFs Adaptive 0.85 200 Medium-term rotation filter
Crypto Adaptive 1.00 150 Volatility-responsive swing filter
Commodities Fixed 70/30 100 Mean reversion model
Alerts Included
Daily RSI crossed above/below Weekly RSI
Composite RSI > Risk-On threshold
Composite RSI < Risk-Off threshold
All RSI aligned above/below 50
Z-Score Conformity (All positive or all negative)
Overbought/Oversold triggers
Author’s Note
This indicator was designed for research and systematic confluence analysis within Mongoose Capital Labs.
It is not financial advice and should be used in combination with independent risk assessment, volume confirmation, and higher-timeframe context.
Liquidity Pool TimesThis script automatically plots key liquidity pool times on your chart. I will release an updated script that plots the names on the far right when i can figure it out. Until then you will see Monthly Open/Close Weekly Open/Close and Midnight/10AM open
Iron Condor & Butterfly VisualizerIt helps you visualize and manage your option spread by:
Plotting strike prices and breakeven lines directly on the chart.
Showing profit/loss zones, adjustment zones, and alerts when price nears critical levels.
Calculating risk/reward, probability of profit, theta decay, IV condition, and trade score.
🎯 2. Inputs & Configuration
You input your trade details as a comma-separated string:
For an Iron Condor
ShortCall, LongCall, ShortPut, LongPut, Credit, Contracts, Target%
Example: 626,628,620,618,1.20,1,30
For a Butterfly Spread
LowerWing, Body, UpperWing, Debit, Contracts, Target%
Example: 600,620,640,2.50,2,50
The indicator automatically parses this and knows which strategy type you selected.
You can also control:
Visuals (profit zones, breakevens, labels)
Risk (stop loss %, adjustment zones)
Account/risk sizing
Market conditions (IV Rank, current IV, DTE)
⚙️ 3. Data Parsing & Strategy Recognition
The code reads your pasted string, splits it by commas, and determines:
Which strikes are short vs long (or wings/body for Butterfly)
Whether the strategy is credit (Iron Condor) or debit (Butterfly)
Calculates net credit/debit, contract size, and profit target
📈 4. Profit/Loss Calculations
It dynamically calculates:
Max Profit
Iron Condor: net credit × 100 × contracts
Butterfly: (wing width − debit) × 100 × contracts
Max Loss
Iron Condor: difference between strikes minus credit
Butterfly: debit × 100 × contracts
Breakeven points
Iron Condor: short strikes ± net credit
Butterfly: body ± debit
Current P&L relative to the live price (close).
⚖️ 5. Risk & Position Sizing
It checks:
Stop-loss trigger (% of max loss)
Adjustment alert if price nears short strikes
Recommended contract size based on account size and % risk per trade
Actual % of account at risk
⏱️ 6. Time Decay & IV Analysis
If you input days to expiration, it shows:
Theta (approx daily time decay)
Decay progress bar (% of 30-day cycle)
IV condition:
Green: favorable (>50 IV Rank)
Yellow: neutral (30–50)
Red: poor (<30)
🧮 7. Trade Scoring
It gives a Trade Score (0–100) based on:
IV Rank (favorable market)
Risk/Reward ratio
Probability of profit
Default 20 baseline points
This helps gauge whether the setup is statistically attractive.
🧠 8. Visualizations
When the indicator runs, it draws on your chart:
Lines
Red = short strikes
Orange dashed = long strikes
Yellow dotted = breakeven levels
Boxes
Green = profit zone
Orange shaded = adjustment zones (approaching danger)
Labels (optional)
Strike labels (call/put prices)
Info box summarizing:
Profit, loss, risk/reward
Breakevens, theta, target, gamma risk flag
🚨 9. Alerts
The script triggers TradingView alerts when:
Price nears call or put adjustment zones
Profit target is hit
Stop loss is hit
These help you manage the trade without constant monitoring.
🧭 10. In Practice
You’d:
Copy the option strikes and trade details from your broker or analyzer.
Paste them into 📋 PASTE YOUR TRADE DATA HERE.
The indicator plots:
Profit/loss region
Adjustment warnings
Key metrics
Alerts if your trade is in danger or near target.
TMA SWING USE HOURLY TFTma Swing use hourly is a very strong potential buy and sell signal strategy where it give buy signal when 50 ema croses 200 ema and vise versa
ScalpGawd Risk Reward//@version=5
indicator("ScalpGawd Risk Reward", overlay=true)
i_fromDate = input.time(timestamp("2024-02-01T00:00:00"), title="Entry Time")
i_entryPrice = input.float(4000, "Entry Price")
i_slPrice = input.float(3900, "Stop Loss Price")
i_distance = input.int(100, "Horizontal Distance (in Time Units)", group="Styling")
i_entryColor = input.color(color.white, "Entry Line", inline="Entry", group="Styling")
i_entryStyle = input.string("solid", title="", options= , inline="Entry", group="Styling")
i_entryWidth = input.int(1, "", inline="Entry", group="Styling")
i_slColor = input.color(color.red, "SL Line", inline="SL", group="Styling")
i_slStyle = input.string("solid", title="", options= , inline="SL", group="Styling")
i_slWidth = input.int(2, "", inline="SL", group="Styling")
i_tpColor = input.color(color.green, "TP Line", inline="TP", group="Styling")
i_tpStyle = input.string("solid", title="", options= , inline="TP", group="Styling")
i_tpWidth = input.int(2, "", inline="TP", group="Styling")
i_labelSize = input.string("tiny", "Label Size", options= , group="Label")
i_labelOffset = input.int(2, "Label Offset", group="Label")
i_useTP1 = input.bool(true, "1", inline="1", group="Show Take Profit")
i_useTP2 = input.bool(true, "2", inline="1", group="Show Take Profit")
i_useTP3 = input.bool(true, "3", inline="1", group="Show Take Profit")
i_useTP4 = input.bool(true, "4", inline="1", group="Show Take Profit")
i_useTP5 = input.bool(true, "5", inline="1", group="Show Take Profit")
i_useTP6 = input.bool(true, "6", inline="1", group="Show Take Profit")
i_useTP7 = input.bool(true, "7", inline="1", group="Show Take Profit")
i_useTP8 = input.bool(true, "8", inline="1", group="Show Take Profit")
i_useTP9 = input.bool(true, "9", inline="1", group="Show Take Profit")
i_useTP10 = input.bool(true, "10", inline="1", group="Show Take Profit")
var int barDistance = na
if bar_index < 2
barDistance := time - time
else
barDistance := math.min(barDistance, time - time )
int distanceInTime = barDistance * i_distance
var line entryLine = na, line.delete(entryLine)
var line stopLossLine = na, line.delete(stopLossLine)
var line tpLine1 = na, line.delete(tpLine1)
var line tpLine2 = na, line.delete(tpLine2)
var line tpLine3 = na, line.delete(tpLine3)
var line tpLine4 = na, line.delete(tpLine4)
var line tpLine5 = na, line.delete(tpLine5)
var line tpLine6 = na, line.delete(tpLine6)
var line tpLine7 = na, line.delete(tpLine7)
var line tpLine8 = na, line.delete(tpLine8)
var line tpLine9 = na, line.delete(tpLine9)
var line tpLine10 = na, line.delete(tpLine10)
var label entryLabel = na, label.delete(entryLabel)
var label slLabel = na, label.delete(slLabel)
var label tpLabel1 = na, label.delete(tpLabel1)
var label tpLabel2 = na, label.delete(tpLabel2)
var label tpLabel3 = na, label.delete(tpLabel3)
var label tpLabel4 = na, label.delete(tpLabel4)
var label tpLabel5 = na, label.delete(tpLabel5)
var label tpLabel6 = na, label.delete(tpLabel6)
var label tpLabel7 = na, label.delete(tpLabel7)
var label tpLabel8 = na, label.delete(tpLabel8)
var label tpLabel9 = na, label.delete(tpLabel9)
var label tpLabel10 = na, label.delete(tpLabel10)
float i_tp1Price = i_entryPrice + (i_entryPrice - i_slPrice)
float i_tp2Price = i_entryPrice + (i_entryPrice - i_slPrice) * 2
float i_tp3Price = i_entryPrice + (i_entryPrice - i_slPrice) * 3
float i_tp4Price = i_entryPrice + (i_entryPrice - i_slPrice) * 4
float i_tp5Price = i_entryPrice + (i_entryPrice - i_slPrice) * 5
float i_tp6Price = i_entryPrice + (i_entryPrice - i_slPrice) * 6
float i_tp7Price = i_entryPrice + (i_entryPrice - i_slPrice) * 7
float i_tp8Price = i_entryPrice + (i_entryPrice - i_slPrice) * 8
float i_tp9Price = i_entryPrice + (i_entryPrice - i_slPrice) * 9
float i_tp10Price = i_entryPrice + (i_entryPrice - i_slPrice) * 10
f_getStyle(_style) =>
ret = line.style_solid
if _style == "dotted"
ret := line.style_dotted
else if _style == "dashed"
ret := line.style_dashed
ret
f_getLabelSize() =>
ret = size.normal
if i_labelSize == "small"
ret := size.small
else if i_labelSize == "tiny"
ret := size.tiny
ret
entryLine := line.new(i_fromDate, i_entryPrice, i_fromDate + distanceInTime, i_entryPrice, xloc=xloc.bar_time, color=i_entryColor, width=i_entryWidth, style=f_getStyle(i_entryStyle))
stopLossLine := line.new(i_fromDate, i_slPrice, i_fromDate + distanceInTime, i_slPrice, xloc=xloc.bar_time, color=i_slColor, width=i_slWidth, style=f_getStyle(i_slStyle))
tpLine1 := i_useTP1 ? line.new(i_fromDate, i_tp1Price, i_fromDate + distanceInTime, i_tp1Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine2 := i_useTP2 ? line.new(i_fromDate, i_tp2Price, i_fromDate + distanceInTime, i_tp2Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine3 := i_useTP3 ? line.new(i_fromDate, i_tp3Price, i_fromDate + distanceInTime, i_tp3Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine4 := i_useTP4 ? line.new(i_fromDate, i_tp4Price, i_fromDate + distanceInTime, i_tp4Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine5 := i_useTP5 ? line.new(i_fromDate, i_tp5Price, i_fromDate + distanceInTime, i_tp5Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine6 := i_useTP6 ? line.new(i_fromDate, i_tp6Price, i_fromDate + distanceInTime, i_tp6Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine7 := i_useTP7 ? line.new(i_fromDate, i_tp7Price, i_fromDate + distanceInTime, i_tp7Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine8 := i_useTP8 ? line.new(i_fromDate, i_tp8Price, i_fromDate + distanceInTime, i_tp8Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine9 := i_useTP9 ? line.new(i_fromDate, i_tp9Price, i_fromDate + distanceInTime, i_tp9Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine10 := i_useTP10 ? line.new(i_fromDate, i_tp10Price, i_fromDate + distanceInTime, i_tp10Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
entryLabel := label.new(i_fromDate + barDistance * i_labelOffset, i_entryPrice, text="Entry @ " + str.tostring(i_entryPrice, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_entryColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize())
slLabel := label.new(i_fromDate + barDistance * i_labelOffset, i_slPrice, text="Stop Loss " + str.tostring((i_slPrice - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_slPrice, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_slColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize())
tpLabel1 := i_useTP1 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp1Price, text="Target 1 " + str.tostring((i_tp1Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp1Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel2 := i_useTP2 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp2Price, text="Target 2 " + str.tostring((i_tp2Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp2Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel3 := i_useTP3 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp3Price, text="Target 3 " + str.tostring((i_tp3Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp3Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel4 := i_useTP4 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp4Price, text="Target 4 " + str.tostring((i_tp4Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp4Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel5 := i_useTP5 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp5Price, text="Target 5 " + str.tostring((i_tp5Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp5Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel6 := i_useTP6 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp6Price, text="Target 6 " + str.tostring((i_tp6Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp6Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel7 := i_useTP7 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp7Price, text="Target 7 " + str.tostring((i_tp7Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp7Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel8 := i_useTP8 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp8Price, text="Target 8 " + str.tostring((i_tp8Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp8Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel9 := i_useTP9 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp9Price, text="Target 9 " + str.tostring((i_tp9Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp9Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel10 := i_useTP10 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp10Price, text="Target 10 " + str.tostring((i_tp10Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp10Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
i_showBox = input.bool(true, "Show Background", group="Show Background")
var box greenBox = na, box.delete(greenBox)
var box redBox = na, box.delete(redBox)
f_findHighestTP() =>
ret = i_tp1Price
if i_useTP10
ret := i_tp10Price
else if i_useTP9
ret := i_tp9Price
else if i_useTP8
ret := i_tp8Price
else if i_useTP7
ret := i_tp7Price
else if i_useTP6
ret := i_tp6Price
else if i_useTP5
ret := i_tp5Price
else if i_useTP4
ret := i_tp4Price
else if i_useTP3
ret := i_tp3Price
else if i_useTP2
ret := i_tp2Price
ret
greenBox := i_showBox ? box.new(i_fromDate, i_entryPrice, i_fromDate + distanceInTime, f_findHighestTP(), xloc=xloc.bar_time, bgcolor=color.new(i_tpColor, 70), border_width = 0) : na
redBox := i_showBox ? box.new(i_fromDate, i_entryPrice, i_fromDate + distanceInTime, i_slPrice, xloc=xloc.bar_time, bgcolor=color.new(i_slColor, 70), border_width = 0) : na
TMA BUY TMA buy mometum indiactor , which helps you to identify mometum traders very simple . it gfives buy signal when you price croses 50 ema .
TFX AVERAGESThis indicator created by TFX features the EMA's of 5, 10, 20, 50, 200. These indicators will show the averages of candles.
MirPapa_Lib_trendLibrary: MirPapa_Lib_trend
getMaColor(level)
Parameters:
level (int): 1 = lowest, 2 = low, 3 = mid, 4 = high, 5 = highest, 6 = base
getMA(mode, src, len)
Parameters:
mode (string): MA type
src (float): source
len (simple int): period
Returns: selected MA
getMA(maName, src, intLow, intMid, intHigh)
Parameters:
maName (string): MA type
src (float): source
intLow (simple int): short-term
intMid (simple int): mid-term
intHigh (simple int): long-term
Returns: array
getMA(maName, src, intLowest, intLow, intMid, intHigh, intHighest, intBase)
Parameters:
maName (string): MA type
src (float): source
intLowest (simple int): ultra-short
intLow (simple int): short
intMid (simple int): mid
intHigh (simple int): long
intHighest (simple int): ultra-long
intBase (simple int): base line
Returns: array
getStochastic(src, intLen)
Parameters:
src (float): source
intLen (int): period
Returns: selected stochastic
getStochastic(src, intLow, intMid, intHigh)
Parameters:
src (float): source
intLow (int): short-term
intMid (int): mid-term
intHigh (int): long-term
Returns:
getStochastic(src, intLowest, intLow, intMid, intHigh, intHighest, intBase)
Parameters:
src (float): source
intLowest (int): ultra-short
intLow (int): short
intMid (int): mid
intHigh (int): long
intHighest (int): ultra-long
intBase (int): base
Returns:
getRSX(src, intLen)
Parameters:
src (float): source
intLen (int): period
Returns: selected RSX
getRSX(src, intLow, intMid, intHigh)
Parameters:
src (float): source
intLow (int): short-term
intMid (int): mid-term
intHigh (int): long-term
Returns:
getRSX(src, intLowest, intLow, intMid, intHigh, intHighest, intBase)
Parameters:
src (float): source
intLowest (int): ultra-short
intLow (int): short
intMid (int): mid
intHigh (int): long
intHighest (int): ultra-long
intBase (int): base
Returns:
getMACD(src, fastLen, slowLen, signalLen)
Parameters:
src (float): source
fastLen (simple int): fast EMA period
slowLen (simple int): slow EMA period
signalLen (simple int): signal line period
Returns:
getBollingerBand(src, len, mult)
Parameters:
src (float): source
len (int): period
mult (float): standard deviation multiplier
Returns:
getATR(intLen)
Parameters:
intLen (simple int): ATR period
Returns: selected ATR
getATR(intLow, intMid, intHigh)
Parameters:
intLow (simple int): short-term
intMid (simple int): mid-term
intHigh (simple int): long-term
Returns: array
getATR(intLowest, intLow, intMid, intHigh, intHighest, intBase)
Parameters:
intLowest (simple int): ultra-short
intLow (simple int): short
intMid (simple int): mid
intHigh (simple int): long
intHighest (simple int): ultra-long
intBase (simple int): base
isCross(fastLine, baseLine)
Parameters:
fastLine (float): fast line
baseLine (float): base line
Returns: state (true/false)
isMAtrend(maLow, maMid, maHigh)
Parameters:
maLow (float): fast MA
maMid (float): mid MA
maHigh (float): slow MA
Returns: trend state
isMAline(val, valPrev, intBaseLine)
Parameters:
val (float): current value
valPrev (float): previous value
intBaseLine (int): base value
Returns: state
getStage(v1, v2, v3)
Parameters:
v1 (float): first value
v2 (float): second value
v3 (float): third value
Returns: stage number (1–6)
getBgColor(stage)
Parameters:
stage (int): stage number
Returns: color
getBgColor(stage, transp)
Parameters:
stage (int): stage number
transp (int): transparency
Returns: color
getBGColor(v1, v2, v3)
Parameters:
v1 (float): first value
v2 (float): second value
v3 (float): third value
Returns: color
getBGColor(v1, v2, v3, transp)
Parameters:
v1 (float): first value
v2 (float): second value
v3 (float): third value
transp (int): transparency
Returns: color
createStackedLabel(labelText, isUp, maLowest, maLow, maMid, maHigh, maHighest, maBase)
Parameters:
labelText (string): label text
isUp (bool): true = up, false = down
maLowest (float)
maLow (float)
maMid (float)
maHigh (float)
maHighest (float)
maBase (float)
Returns: created label
isDoubleBottom(src, left, right)
Parameters:
src (float): reference series (e.g., mid MA or low)
left (int): left bar count for pivot search
right (int): right bar count for pivot search
Returns: true if double bottom detected (previous pivot low < current pivot low)
isDoubleTop(src, left, right)
Parameters:
src (float): reference series (e.g., mid MA or high)
left (int): left bar count for pivot search
right (int): right bar count for pivot search
Returns: true if double top detected (previous pivot high > current pivot high)
isFractalHigh(src, left, right)
Parameters:
src (float): high series (e.g., high or mid MA)
left (int): left confirmation bars
right (int): right confirmation bars
Returns: true if fractal high detected
isFractalLow(src, left, right)
Parameters:
src (float): low series (e.g., low or mid MA)
left (int): left confirmation bars
right (int): right confirmation bars
Returns: true if fractal low detected
VWAP Reversion (Sequential Stats + Profit/Loss Points)First time posting. This is my attempt to evaluate the effectiveness of VWAP reversion. I decided to make this an indicator with its own integrated stats.
If you set the session length to lets say 100, but choose a 1 minute timeframe, it will only load as many sessions as the chart will allow for that timeframe. increasing the timeframe will allow you to go back further with more sessions.
I plan to implement more and more as I refine it. I just wanted to get my working copy out into the universe. I'd like to add some method of "scaling in". Perhaps if the price goes further and further away from the original entry, say for each additional std. deviation band further, it could add another entry signal.
My trading journey is just beginning, I've never coded before, and this was made entirely through the fusion of my attempt to communicate the ideas in my head for ChatGPT to turn into code!
Trappp's Advanced Multi-Timeframe Trading ToolkitTrappp's Advanced Multi-Timeframe Trading Toolkit
This comprehensive trading script by Trappp provides a complete market analysis framework with multiple timeframe support and resistance levels. The indicator features:
Key Levels:
· Monthly (light blue dashed) and Weekly (gold dashed) levels for long-term context
· Previous day high/low (yellow) with range display
· Pivot-based support/resistance (pink dashed)
· Premarket levels (blue) for pre-market activity
Intraday Levels:
· 1-minute opening candle (red)
· 5-minute (white), 15-minute (green), and 30-minute (purple) session levels
· All intraday levels extend right throughout the trading day
Technical Features:
· EMA 50/200 cross detection with alert labels
· Candlestick pattern recognition near key levels
· Smart proximity detection using ATR
· Automatic daily/weekly/monthly updates
Trappp's script is designed for traders who need immediate visual reference of critical price levels across multiple timeframes, helping identify potential breakouts, reversals, and pattern-based setups with clear, color-coded visuals for quick decision-making.
BlackScrum Swing Boxes 1/2/3 After seeing influencers selling their indicator suite's online, I decided to start making replicas of them, maybe mine are better, maybe they are worse. I use them in my day to day trading and they help me make money, hopefully they help you make money.
Not financial advice, Do Your Own Research.
Everything provided without warranty or liability. If you stuff up, learn from it, get better, we all make mistakes.
// BlackScrum — 1/2/3-Bar Swing Boxes (auto timeframe)
//
// DESCRIPTION
// This indicator displays three swing-direction boxes (1B, 2B, 3B) in the top-right corner of the chart.
// The boxes automatically adapt to the chart's timeframe (15m, 1H, 4H, 1D, etc.).
// Each box represents the direction of the most recently confirmed swing pivot:
// • 1B → 1-bar swing (fastest, most sensitive)
// • 2B → 2-bar swing (medium confirmation)
// • 3B → 3-bar swing (slowest, strongest confirmation)
//
// COLORS
// • GREEN = last confirmed swing pivot was a higher low (up swing)
// • RED = last confirmed swing pivot was a lower high (down swing)
// • GREY = no clear swing yet (fresh/transition area)
//
// CONFLUENCE
// • ALL GREEN = bullish alignment across 1B, 2B, 3B → strong trend continuation signal
// • ALL RED = bearish alignment across all three → strong downtrend continuation signal
//
// HOW TO USE (TRADEPLAY)
//
// 1) ENTRIES
// • Aggressive entry → enter when ALL GREEN prints on your timeframe.
// • Safer pullback entry → wait for 1B to briefly turn red during a green 2B/3B,
// then flip back to green. Enter on the re-flip.
// • Multi-timeframe filter:
// Take longs only when higher TF (e.g., 1H/4H) boxes are at least neutral-to-green.
//
// 2) EXITS
// • Weakness exit → when 1B flips against your position while 2B is neutral/red.
// • Full exit → when ALL RED prints.
// • Time stop → if price hasn’t moved after several bars of your execution timeframe.
//
// 3) STOP-LOSS / RISK
// • Place stops beyond the latest opposite swing used by 2B or 3B.
// • Add 0.5–1× ATR buffer if your market has stop-hunt volatility.
// • Always size position based on the distance to the swing stop.
//
// 4) WHEN TO IGNORE SIGNALS
// • Chop zones → 1B flipping repeatedly while 2B/3B disagree.
// • News candles → wait for pivots to confirm on the *closed* bar.
//
// 5) USING WITH OTHER TOOLS
// • With a trend ribbon (e.g., Larsson-style):
// Only take ALL GREEN longs when the ribbon is UP, and ALL RED shorts when ribbon is DOWN.
// • With a Fear & Greed index:
// Prefer longs when F&G > 60,
// Avoid longs when F&G < 40 unless countertrend scalping.
//
// 6) TIMEFRAME GUIDANCE
// • Scalping: 5m / 15m, confirmed by 1H or 4H boxes.
// • Swinging: 1H / 4H with daily filter.
// • Positioning: 1D with weekly confirmation.
//
// 7) INTERPRETATION CHEATSHEET
// • 1B green, 2B grey, 3B red → short-term bounce inside higher timeframe downtrend.
// • 1B/2B green, 3B grey → early trend reversal forming.
// • All grey → fresh swing area; wait for direction.
//
// 8) CUSTOMIZATION
// • len1 / len2 / len3 control sensitivity (higher = slower & cleaner).
// • Can add a timeframe header box (e.g., “15m / 4H / 1D”).
// • Can add a multi-timeframe grid (e.g., 15m | 1H | 4H | 1D each with 1B/2B/3B).
//
// ====================================================================================================
Liquidity Regime OscillatorThe Liquidity Signal Line is a macro-driven confirmation tool designed to capture the underlying global liquidity regime in a single, smoothed oscillator. It measures the combined directional flow of monetary and financial conditions using high-impact macro data: Federal Reserve assets (WALCL), Treasury General Account (TGA), and the Overnight Reverse Repo facility (RRP) – adjusted by key market proxies such as the U.S. Dollar Index, credit spreads (HYG/LQD), and equity risk appetite (SPHB/SPHQ). These components are normalized, weighted, and then double-smoothed into a stable signal that translates complex liquidity dynamics into a simple 0–100 scale.
Liquidity expansion provides fuel for risk assets, while contraction drains leverage and risk appetite. The Signal Line acts as a confirmation overlay for trend and allocation strategies, showing whether systemic liquidity is broadly supportive or restrictive. Readings above 50 indicate an expansionary environment (risk-on bias), below 50 a contractionary one (risk-off bias). Because the calculation uses higher-timeframe macro data, it can be displayed on any chart to give traders a consistent, regime-aware signal that bridges macro policy and technical execution.
lower_tfLibrary "lower_tf"
█ OVERVIEW
This library is an enhanced (opinionated) version of the library originally developed by PineCoders contained in lower_tf .
It is a Pine Script® programming tool for advanced lower-timeframe selection and intra-bar analysis.
█ CONCEPTS
Lower Timeframe Analysis
Lower timeframe analysis refers to the analysis of price action and market microstructure using data from timeframes shorter than the current chart period. This technique allows traders and analysts to gain deeper insights into market dynamics, volume distribution, and the price movements occurring within each bar on the chart. In Pine Script®, the request.security_lower_tf() function allows this analysis by accessing intrabar data.
The library provides a comprehensive set of functions for accurate mapping of lower timeframes, dynamic precision control, and optimized historical coverage using request.security_lower_tf().
█ IMPROVEMENTS
The original library implemented ten precision levels. This enhanced version extends that to twelve levels, adding two ultra-high-precision options:
Coverage-Based Precision (Original 5 levels):
1. "Covering most chart bars (least precise)"
2. "Covering some chart bars (less precise)"
3. "Covering fewer chart bars (more precise)"
4. "Covering few chart bars (very precise)"
5. "Covering the least chart bars (most precise)"
Intrabar-Count-Based Precision (Expanded from 5 to 7 levels):
6. "~12 intrabars per chart bar"
7. "~24 intrabars per chart bar"
8. "~50 intrabars per chart bar"
9. "~100 intrabars per chart bar"
10. "~250 intrabars per chart bar"
11. "~500 intrabars per chart bar" ← NEW
12. "~1000 intrabars per chart bar" ← NEW
The key enhancements in this version include:
1. Extended Precision Range: Adds two ultra-high-precision levels (~500 and ~1000 intrabars) for advanced microstructure analysis requiring maximum granularity.
2. Market-Agnostic Implementation: Eliminates the distinction between crypto/forex and traditional markets, removing the mktFactor variable in favor of a unified, predictable approach across all asset classes.
3. Explicit Precision Mapping: Completely refactors the timeframe selection logic using native Pine Script® timeframe properties ( timeframe.isseconds , timeframe.isminutes , timeframe.isdaily , timeframe.isweekly , timeframe.ismonthly ) and explicit multiplier-based lookup tables. The original library used minute-based calculations with market-dependent conditionals that produced inconsistent results. This version provides deterministic, predictable mappings for every chart timeframe, ensuring consistent precision behavior regardless of asset type or market hours.
An example of the differences can be seen side-by-side in the chart below, where the original library is on the left and the enhanced version is on the right:
█ USAGE EXAMPLE
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at mozilla.org
// © andre_007
//@version=6
indicator("lower_tf Example")
import andre_007/lower_tf/1 as LTF
import PineCoders/Time/5 as PCtime
//#region ———————————————————— Example code
// ————— Constants
color WHITE = color.white
color GRAY = color.gray
string LTF1 = "Covering most chart bars (least precise)"
string LTF2 = "Covering some chart bars (less precise)"
string LTF3 = "Covering less chart bars (more precise)"
string LTF4 = "Covering few chart bars (very precise)"
string LTF5 = "Covering the least chart bars (most precise)"
string LTF6 = "~12 intrabars per chart bar"
string LTF7 = "~24 intrabars per chart bar"
string LTF8 = "~50 intrabars per chart bar"
string LTF9 = "~100 intrabars per chart bar"
string LTF10 = "~250 intrabars per chart bar"
string LTF11 = "~500 intrabars per chart bar"
string LTF12 = "~1000 intrabars per chart bar"
string TT_LTF = "This selection determines the approximate number of intrabars analyzed per chart bar. Higher numbers of
intrabars produce more granular data at the cost of less historical bar coverage, because the maximum number of
available intrabars is 200K.
The first five options set the lower timeframe based on a specified relative level of chart bar coverage.
The last five options set the lower timeframe based on an approximate number of intrabars per chart bar."
string TAB_TXT = "Uses intrabars at the {0} timeframe. Avg intrabars per chart bar:
{1,number,#.#} Chart bars covered: {2} of {3} ({4,number,#.##}%)"
string ERR_TXT = "No intrabar information exists at the {1}{0}{1} timeframe."
// ————— Inputs
string ltfModeInput = input.string(LTF3, "Intrabar precision", options = , tooltip = TT_LTF)
bool showInfoBoxInput = input.bool(true, "Show information box ")
string infoBoxSizeInput = input.string("normal", "Size ", inline = "01", options = )
string infoBoxYPosInput = input.string("bottom", "↕", inline = "01", options = )
string infoBoxXPosInput = input.string("right", "↔", inline = "01", options = )
color infoBoxColorInput = input.color(GRAY, "", inline = "01")
color infoBoxTxtColorInput = input.color(WHITE, "T", inline = "01")
// ————— Calculations
// @variable A "string" representing the lower timeframe for the data request.
// NOTE:
// This line is a good example where using `var` in the declaration can improve a script's performance.
// By using `var` here, the script calls `ltf()` only once, on the dataset's first bar, instead of redundantly
// evaluating unchanging strings on every bar. We only need one evaluation of this function because the selected
// timeframe does not change across bars in this script.
var string ltfString = LTF.ltf(ltfModeInput, LTF1, LTF2, LTF3, LTF4, LTF5, LTF6, LTF7, LTF8, LTF9, LTF10, LTF11, LTF12)
// @variable An array containing all intrabar `close` prices from the `ltfString` timeframe for the current chart bar.
array intrabarCloses = request.security_lower_tf(syminfo.tickerid, ltfString, close)
// Calculate the intrabar stats.
= LTF.ltfStats(intrabarCloses)
int chartBars = bar_index + 1
// ————— Visuals
// Plot the `avgIntrabars` and `intrabars` series in all display locations.
plot(avgIntrabars, "Average intrabars", color.silver, 6)
plot(intrabars, "Intrabars", color.blue, 2)
// Plot the `chartBarsCovered` and `chartBars` values in the Data Window and the script's status line.
plot(chartBarsCovered, "Chart bars covered", display = display.data_window + display.status_line)
plot(chartBars, "Chart bars total", display = display.data_window + display.status_line)
// Information box logic.
if showInfoBoxInput
// @variable A single-cell table that displays intrabar information.
var table infoBox = table.new(infoBoxYPosInput + "_" + infoBoxXPosInput, 1, 1)
// @variable The span of the `ltfString` timeframe formatted as a number of automatically selected time units.
string formattedLtf = PCtime.formattedNoOfPeriods(timeframe.in_seconds(ltfString) * 1000)
// @variable A "string" containing the formatted text to display in the `infoBox`.
string txt = str.format(
TAB_TXT, formattedLtf, avgIntrabars, chartBarsCovered, chartBars, chartBarsCovered / chartBars * 100, "'"
)
// Initialize the `infoBox` cell on the first bar.
if barstate.isfirst
table.cell(
infoBox, 0, 0, txt, text_color = infoBoxTxtColorInput, text_size = infoBoxSizeInput,
bgcolor = infoBoxColorInput
)
// Update the cell's text on the latest bar.
else if barstate.islast
table.cell_set_text(infoBox, 0, 0, txt)
// Raise a runtime error if no intrabar data is available.
if ta.cum(intrabars) == 0 and barstate.islast
runtime.error(str.format(ERR_TXT, ltfString, "'"))
//#endregion
█ EXPORTED FUNCTIONS
ltf(userSelection, choice1, choice2, ...)
Returns the optimal lower timeframe string based on user selection and current chart timeframe. Dynamically calculates precision to balance granularity with historical coverage within the 200K intrabar limit.
ltfStats(intrabarValues)
Analyzes an intrabar array returned by request.security_lower_tf() and returns statistics: number of intrabars in current bar, total chart bars covered, and average intrabars per bar.
█ CREDITS AND LICENSING
Original Concept : PineCoders Team
Original Lower TF Library :
License : Mozilla Public License 2.0
Adil Hoca - US Market Score Only NasdaqMarket Score & Crash Detector Indicator
User Guide & Usage Instructions
This TradingView indicator provides a comprehensive market risk assessment, combining multiple financial metrics to detect potential market crashes, recessions, and overall trend regimes. It is especially designed to alert traders and investors about early warning signals before significant market downturns, enabling proactive decision-making.
Key Features
Multi-Metric Market Sentiment: Uses volatility indices, currency strength, yield spreads, breadth, and bond ratios to evaluate market health.
Crash Detection System: Monitors various conditions such as VIX spikes, breadth collapse, momentum cliffs, high-yield spread surges, and hidden market weaknesses.
Reccession Indicator: Incorporates the Sahm Rule, a proven recession indicator based on employment data.
Alert System: Sends real-time alerts for critical market conditions, including crashes, recession signals, and spreads alerts.
Visual Elements: Includes histograms, trend lines, threshold lines, and shape signals to visually interpret market states.
Customizable Parameters: Adjust weights, sensitivity, thresholds, and alert preferences to suit your trading style.
How it Works
1. Data Collection
The indicator fetches data from multiple sources:
Market volatility: VIX index
Currency strength: DXY index
Interest rates: SOFR, PCE inflation
Yield spreads: High Yield Credit Spread, Investment Grade Spread
Market Breadth: Ratio of QQQ to TLT (tech vs. bonds)
Bond Ratios: TMF/TMV (long-term bonds)
Employment Data: The Sahm Rule (monthly unemployment data)
2. Normalization
Data is normalized via z-score calculations over defined periods to standardize the metrics, making them comparable regardless of their original scale.
3. Composite Score Calculation
Each metric is weighted according to user-defined parameters, and a composite score is generated to represent the overall market sentiment, smoothed with an EMA for trend clarity.
4. Crash & Recession Detection
Crash System: Looks for conditions like VIX spikes, breadth collapse, momentum drops, high yield spread surges, and hidden weaknesses. If multiple conditions meet thresholds, alerts trigger.
Recession Indicator: Uses the Sahm Rule, which compares the current unemployment rate's three-month average to the lowest point over the past 12 months. When it exceeds a certain threshold, a recession signal is generated.
5. Alerts & Visualization
Sound & Shape Alerts: Signals like warning triangles, cross icons, and color changes.
Threshold Lines: Indicate levels like "Strong Bullish," "Strong Bear," and critical zones.
Dual Confirmation: Combines crash and recession signals for high-confidence alerts.
Usage & Customization
Placing the Indicator
Copy and paste the Pine Script code into TradingView's Pine Editor.
Save and add the script to your chart. Adjust inputs like weights, sensitivity mode, thresholds, and alert preferences via the input panel.
Key Inputs
Weights: Customize the importance of each metric.
Sensitivity Mode: Changes alert thresholds for early warnings.
Crash Sensitivity: Defines how many indicators need to trigger before issuing a crash alert.
Recession Thresholds: Set the unemployment level that signals recession.
Interpreting Visuals
Histogram: Shows the composite score; green means bullish, red indicates bearish.
Momentum Line: Highlights trend acceleration/deceleration.
Threshold Lines: Dotted/dashed lines showing critical zones.
Shape Shapes: Triangles or crosses appear for early signals or critical events.
Alerts
Crash Alerts: Warn of imminent market crashes.
Recession Alerts: Indicate economic downturns based on Sahm Rule.
Spread Alerts: Show high-yield credit spread surges signaling stress.
Double Confirmation: High-confidence signals when crash and recession conditions align.
Best Practices
Use on multiple timeframes for confirmation.
Combine with other technical analysis tools for better accuracy.
Adjust thresholds according to your risk appetite.
Follow alert signals for early warning but always consider overall context.
Final Notes
This indicator synthesizes a variety of leading and lagging indicators to give a holistic view of market health. It is designed to provide early warnings, especially in volatile or stressed environments, helping traders avoid severe drawdowns or position ahead of major downturns.
Feel free to modify input parameters for your preferences, or integrate additional data sources for further refinement.
This detailed explanation can be directly included as a description or documentation within your TradingView script, helping users grasp its full capabilities and optimal usage.
dO / wO / mO + MA 50/200 + PrevDay H/L Description
This indicator plots key reference levels used by professional traders:
Daily Open (dO)
Weekly Open (wO)
Monthly Open (mO)
Previous Day High (pdH) and Previous Day Low (pdL)
Moving Averages: 50 & 200 SMA
Each level is drawn as a clean dotted white line with a fixed label directly on the price chart.
All levels can be individually toggled on or off via checkboxes in the settings panel.
The pdH/pdL lines start exactly from the candles that created them, providing clear structure for breakout, retracement, and liquidity analysis.
The 50/200 SMA are included for long-term trend context.
This tool is designed for traders who rely on multi-timeframe structure and precision levels for both intraday and swing strategies.
Features
Toggle visibility for dO, wO, mO, pdH, and pdL
Accurate placement of previous day levels
Lightweight and responsive
Clean minimal visual design
Supports any symbol and timeframe
Usage Notes
Perfect for confluence-based trading:
Combine pdH/pdL with session opens to identify key liquidity zones
Use SMA 50/200 for directional bias
Works on crypto, forex, indices, and equities
