Cripto chart for updated

//@version=6 // ══════════════════════════════════════════════════════════ // GOLD BREAKOUT 15M STRATEGY [WillyAlgoTrader] // ══════════════════════════════════════════════════════════ // Author: Willy | WillyAlgoTrader // Version: 1.0.0 // // Trades the breakout of the overnight range on gold. // • Range: high / low built between Range Start and Range End (broker time, default 00:00–07:00) // • Entry: stop orders on both range boundaries; the first fill cancels the other. One trade per day // • Stop: percent of the entry price (default 1%) or the opposite range boundary. No take-profit // • Exit: stop-loss, or forced close at Close Hour (default 20:00) // • Size: percent of equity at risk, capped by Max Leverage, rounded down to the quantity step // // Before you trade it // • Built for gold on the 15-minute chart. Use a timeframe that divides an hour evenly (1–60 min), regular candles // • Set Broker Time Mode / Broker Timezone to your broker's server time: the range depends on it // • Default costs: commission 0.4 per order, slippage 0. Spread is not modeled. Adjust them in Properties // • Risk per trade is a target: commission, spread, slippage and gaps come on top of it // • Orders are calculated on bar close and filled on the next bar // • Alerts: create an alert on the strategy and leave only {{strategy.order.alert_message}} in the Message field // ══════════════════════════════════════════════════════════ strategy( title = "Gold Breakout 15M Strategy [WillyAlgoTrader]", shorttitle = "Gold BO 15M", overlay = true, initial_capital = 10000, default_qty_type = strategy.fixed, default_qty_value = 1, calc_on_every_tick = false, process_orders_on_close = false, margin_long = 5, margin_short = 5, commission_type = strategy.commission.cash_per_order, commission_value = 0.4, slippage = 0, max_lines_count = 500, max_labels_count = 500, max_boxes_count = 500, max_bars_back = 5000) // ══════════════════════════════════════════════════════════ // 2. CONSTANTS // ══════════════════════════════════════════════════════════ GRP_MAIN = "⚙️ Main Settings" GRP_RISK = "πŸ›‘️ Risk Management" GRP_VISUAL = "🎨 Visual Settings" GRP_DASH = "πŸ“Š Dashboard" GRP_PERF = "πŸ“ˆ Performance Chart" GRP_ALERT = "πŸ”” Alerts" GRP_COLORS = "🎨 Colors" STRATEGY_VERSION = "v1.0.0" TZ_MODE_FIXED = "Fixed timezone" TZ_MODE_NY7 = "New York + 7h" NY7_SHIFT_MS = 7 * 3600000 NY_TZ = "America/New_York" SL_MODE_PCT = "% of entry" SL_MODE_RANGE = "Range boundary" SIZE_RISK = "% equity at risk" SIZE_FIXED = "Fixed quantity" OCA_GROUP = "RB" NO_VALUE = "—" DEF_JSON_IN = '{"strategy":"Gold Breakout 15M","event":"entry","action":"{{action}}","side":"{{side}}","ticker":"{{ticker}}","price":{{price}},"sl":{{sl}},"qty":{{qty}},"lots":{{lots}},"risk_usd":{{risk_usd}},"range_high":{{range_high}},"range_low":{{range_low}},"secret":"{{secret}}"}' DEF_JSON_OUT = '{"strategy":"Gold Breakout 15M","event":"exit","action":"{{action}}","side":"{{side}}","ticker":"{{ticker}}","reason":"{{reason}}","price":{{price}},"qty":{{qty}},"secret":"{{secret}}"}' DEF_TEXT_LONG_IN = "🟒 BUY | {{tickerid}} | TF: {{interval}} | Price: {{price}} | SL: {{sl}} | Qty: {{qty}} ({{lots}} lots) | Risk: {{risk_usd}}" DEF_TEXT_SHORT_IN = "πŸ”΄ SELL | {{tickerid}} | TF: {{interval}} | Price: {{price}} | SL: {{sl}} | Qty: {{qty}} ({{lots}} lots) | Risk: {{risk_usd}}" DEF_TEXT_LONG_OUT = "⚪ EXIT LONG | {{tickerid}} | TF: {{interval}} | Price: {{price}} | Reason: {{reason}} | Qty: {{qty}}" DEF_TEXT_SHORT_OUT = "⚪ EXIT SHORT | {{tickerid}} | TF: {{interval}} | Price: {{price}} | Reason: {{reason}} | Qty: {{qty}}" TIP_TEMPLATE = "Editable message template. Placeholders are listed in the tooltip of 'Webhook JSON Format'." // ══════════════════════════════════════════════════════════ // 3. INPUTS // ══════════════════════════════════════════════════════════ // ── Main ──────────────────────────────────────── tzModeInput = input.string(TZ_MODE_FIXED, "Broker Time Mode", options = [TZ_MODE_FIXED, TZ_MODE_NY7], group = GRP_MAIN, tooltip = "How broker server time is derived.\n" + "• Fixed timezone: uses 'Broker Timezone' below all year round\n" + "• New York + 7h: server clock used by most FX/CFD brokers (GMT+2 in winter, GMT+3 in summer, US daylight-saving calendar)\n" + "Pick the one matching your broker's server time; a wrong choice shifts the range by an hour for part of the year.") tzInput = input.string("GMT+3", "Broker Timezone", group = GRP_MAIN, tooltip = "Used in 'Fixed timezone' mode. Timezone of your broker's server: all session hours below are in this time.\n" + "• Most FX/CFD brokers use GMT+2 in winter and GMT+3 in summer\n" + "• Examples: GMT+3, GMT+2, UTC, Europe/Moscow") rangeFromInput = input.int(0, "Range Start Hour", minval = 0, maxval = 22, step = 1, group = GRP_MAIN, tooltip = "Hour (broker time) when the daily range starts building.\n" + "• Default: 0 (start of the broker day)") rangeToInput = input.int(7, "Range End / Trading Start Hour", minval = 1, maxval = 23, step = 1, group = GRP_MAIN, tooltip = "Hour when the range is fixed and breakout trading begins.\n" + "• Default 7: range 00:00–06:59, trading from 07:00\n" + "• Later hour = wider range, fewer breakouts") closeHourInput = input.int(20, "Close All Positions Hour", minval = 2, maxval = 23, step = 1, group = GRP_MAIN, tooltip = "Hour when any open position is force-closed.\n" + "• Default: 20. The strategy has no take-profit, this is the main exit") // ── Risk Management ───────────────────────────── slModeInput = input.string(SL_MODE_PCT, "SL Mode", options = [SL_MODE_PCT, SL_MODE_RANGE], group = GRP_RISK, tooltip = "Where the stop-loss is placed.\n" + "• % of entry: fixed percent from the entry price (default 1%). Placed from the breakout level, then re-set from the actual fill price at the close of the entry bar\n" + "• Range boundary: opposite side of the range; a narrow range means a tight stop and a larger position") slPctInput = input.float(1.0, "SL, % of Entry Price", minval = 0.05, maxval = 20.0, step = 0.05, group = GRP_RISK, tooltip = "Stop distance in percent of entry price (used in '% of entry' mode).\n" + "• Higher = wider stop, smaller position\n" + "• Default: 1.0") sizeModeInput = input.string(SIZE_RISK, "Position Size Mode", options = [SIZE_RISK, SIZE_FIXED], group = GRP_RISK, tooltip = "How the order quantity is calculated.\n" + "• % equity at risk: qty = equity × risk% / loss to stop\n" + "• Fixed quantity: constant number of contracts") riskPctInput = input.float(1.0, "Risk per Trade, % of Equity", minval = 0.01, maxval = 100.0, step = 0.1, group = GRP_RISK, tooltip = "Share of equity lost if the stop is hit.\n" + "• Conservative 0.5, balanced 1.0, aggressive 2.0\n" + "• This is a target: commission, spread, slippage and gaps add to the actual loss") fixedQtyInput = input.float(1.0, "Fixed Quantity (contracts)", minval = 0.0001, maxval = 1000000.0, step = 0.01, group = GRP_RISK, tooltip = "Order quantity used in 'Fixed quantity' mode.") lotOzInput = input.float(0.0, "Ounces per Lot (0 = auto)", minval = 0.0, maxval = 1000000.0, step = 1.0, group = GRP_RISK, tooltip = "Used only to show size in lots (labels, dashboard, {{lots}} placeholder) on ounce-quoted instruments.\n" + "• 0 = auto: 100 oz for gold, 5000 oz for silver (standard broker lots)\n" + "• Does not affect trades") maxLeverageInput = input.float(10.0, "Max Leverage", minval = 0.1, maxval = 100.0, step = 1.0, group = GRP_RISK, tooltip = "Upper limit for position notional ÷ equity. Size = the smaller of risk-based size and this cap.\n" + "• 1% risk with 1% stop needs ×1; range-boundary stops usually need ×2–5\n" + "• When the cap is hit, actual risk is lower than requested (shown in the dashboard)\n" + "• Strategy margin is declared as 5% (20x in Properties), so this input is the effective limiter\n" + "• Values near or above 20 also need a higher Long/Short leverage in Properties, otherwise the tester may reject the orders") qtyStepInput = input.float(0.0, "Quantity Step (0 = auto)", minval = 0.0, maxval = 1000000.0, step = 0.01, group = GRP_RISK, tooltip = "Order quantity is rounded DOWN to this step, so the planned risk (before commission, spread and gaps) stays within the budget.\n" + "• 0 = minimum contract size reported by TradingView for the symbol\n" + "• Set your exchange / bot step if it differs\n" + "• If the size is below one step, the entry is skipped") guardOnInput = input.bool(false, "Prop Firm Guard: Close on Daily Drawdown", group = GRP_RISK, tooltip = "Closes everything and stops trading until the next day when equity falls from the daily peak by the limit below.\n" + "• Drawdown is measured at the worst point of each candle (not on the entry candle), but the guard reacts only at candle close\n" + "• For a live prop account use a low timeframe; this is not a guarantee of staying within a firm's limit") guardDdInput = input.float(4.0, "Max Drawdown from Daily Equity Peak, %", minval = 0.1, maxval = 100.0, step = 0.1, group = GRP_RISK, tooltip = "Daily drawdown limit for the Prop Firm Guard.\n" + "• Typical prop firm daily limit: 4–5%") showSlInput = input.bool(true, "Show Entry / SL Levels", group = GRP_RISK, tooltip = "Draw entry price and stop-loss lines with a risk zone while a position is open.") // ── Visual ────────────────────────────────────── themeInput = input.string("Auto", "Theme", options = ["Auto", "Dark", "Light"], group = GRP_VISUAL, tooltip = "Chart color theme.\n" + "• Auto: detects from chart background\n" + "• Dark: optimized for dark backgrounds\n" + "• Light: optimized for light/white backgrounds") showRangeInput = input.bool(true, "Show Range Box & Boundaries", group = GRP_VISUAL, tooltip = "Draw the daily range box and its high/low lines extended over the trading session.") showEntryLabelsInput = input.bool(true, "Show Entry Labels", group = GRP_VISUAL, tooltip = "Label at each entry: direction, entry price, stop, size and risk.") showExitLabelsInput = input.bool(true, "Show Exit Labels (Trade Result)", group = GRP_VISUAL, tooltip = "Label at each exit: P&L in money and in R, price move, exit price and reason.") showTradeBoxInput = input.bool(true, "Show Trade Box (Entry → Exit)", group = GRP_VISUAL, tooltip = "Green/red box between entry and exit of every closed trade.") labelSizeInput = input.string("Small", "Label Size", options = ["Small", "Normal"], group = GRP_VISUAL, tooltip = "Text size of entry/exit labels.") showWarningsInput = input.bool(true, "Show Accuracy Warnings", group = GRP_VISUAL, tooltip = "Note on the last bar when the range may be inaccurate: timeframe above 1H or not dividing an hour evenly, or a non-standard chart (Heikin Ashi, Renko…).\n" + "Informational only: trading is not disabled.") showWatermarkInput = input.bool(true, "Show Watermark", group = GRP_VISUAL, tooltip = "Display 'WillyAlgoTrader' watermark on chart") // ── Dashboard ─────────────────────────────────── showDashInput = input.bool(true, "Show Dashboard", group = GRP_DASH, tooltip = "Status panel with range, session and position calculator.") showMathInput = input.bool(true, "Show Strategy Math", group = GRP_DASH, tooltip = "Trade statistics: win rate, breakeven win rate, profit factor, payoff, expectancy in money and in R, drawdown, losing streak.\n" + "R = trade result divided by the initial risk to the stop.") dashPosInput = input.string("Top Right", "Dashboard Position", options = ["Top Left", "Top Right", "Bottom Left", "Bottom Right", "Middle Right"], group = GRP_DASH, tooltip = "Corner of the chart where the dashboard is placed.") dashSizeInput = input.string("Small", "Dashboard Text Size", options = ["Small", "Normal", "Large"], group = GRP_DASH, tooltip = "Text size of dashboard rows.") // ── Performance Chart ─────────────────────────── showPerfInput = input.bool(false, "Show Performance Chart", group = GRP_PERF, tooltip = "Cumulative PnL curve with key stats, drawn over the chart.\n" + "• Built from closed trades on the bars loaded on the chart — NOT from the Deep Backtesting range\n" + "• Covers the candles behind it while enabled") perfPosInput = input.string("Bottom Left", "Chart Position", options = ["Bottom Left", "Bottom Center", "Bottom Right", "Middle Center", "Top Left", "Top Center"], group = GRP_PERF, tooltip = "Where the performance chart is placed.\n" + "• Bottom Center: the watermark is hidden while the chart is there\n" + "• Same corner as the dashboard: a warning is shown, move one of them") perfColsInput = input.int(80, "Chart Columns", minval = 20, maxval = 150, step = 10, group = GRP_PERF, tooltip = "Horizontal resolution of the curve.\n" + "• Higher = smoother curve, slower drawing\n" + "• Recommended: 60–100") perfRowsInput = input.int(30, "Chart Rows", minval = 10, maxval = 60, step = 5, group = GRP_PERF, tooltip = "Vertical resolution of the curve.\n" + "• Higher = finer steps, slower drawing\n" + "• Recommended: 24–40") perfWidthInput = input.float(50.0, "Chart Width, % of Screen", minval = 20.0, maxval = 90.0, step = 5.0, group = GRP_PERF, tooltip = "Width of the curve area as a share of the chart pane.") perfHeightInput = input.float(35.0, "Chart Height, % of Screen", minval = 10.0, maxval = 70.0, step = 5.0, group = GRP_PERF, tooltip = "Height of the curve area as a share of the chart pane.") // ── Alerts ────────────────────────────────────── enableAlertsInput = input.bool(true, "Enable Alert Messages", group = GRP_ALERT, tooltip = "When off, order alert messages are sent empty.\n" + "Setup: create an alert on this strategy and leave only {{strategy.order.alert_message}} in the Message field.") webhookInput = input.bool(false, "Webhook JSON Format", group = GRP_ALERT, tooltip = "On: JSON templates are sent (for bots / webhooks). Off: text templates.\n\n" + "Placeholders filled by the strategy:\n" + "{{ticker}} {{tickerid}} {{exchange}} {{interval}}\n" + "{{event}} = entry / exit\n" + "{{side}} = long / short\n" + "{{action}} = buy / sell\n" + "{{reason}} = breakout / sl / time / equity_guard\n" + "{{price}} = order level (entry stop / SL) or bar close for time and guard exits — not the fill price\n" + "{{entry}} = entry reference price, {{sl}} = planned stop-loss, {{sl_pct}} = stop distance in % of entry\n" + "{{trade_id}} = ticker + day, identical in the entry and exit messages of one trade\n" + "Note: in '% of entry' mode the stop is re-set from the actual fill and no separate alert is sent. " + "A bot that places its own stop should compute it as {{sl_pct}} from its own fill price.\n" + "{{qty}} = contracts, {{oz}} = qty × point value (ounces on ounce-quoted instruments), {{lots}} = lots\n" + "{{risk_usd}} {{risk_pct}} = initial risk of the trade (entry to SL)\n" + "{{equity}} {{range_high}} {{range_low}} {{secret}}\n\n" + "TradingView's own placeholders (e.g. {{strategy.order.price}}, {{timenow}}) are NOT processed inside these templates. " + "Put them into the Message field of the alert itself, next to {{strategy.order.alert_message}}.") secretInput = input.string("", "Bot Secret → {{secret}}", group = GRP_ALERT, tooltip = "Replaces {{secret}} in templates.\n" + "Note: stored in chart settings and visible to anyone you share the chart with.") jsonLongInInput = input.text_area(DEF_JSON_IN, "JSON · Long Entry", group = GRP_ALERT, tooltip = TIP_TEMPLATE) jsonShortInInput = input.text_area(DEF_JSON_IN, "JSON · Short Entry", group = GRP_ALERT, tooltip = TIP_TEMPLATE) jsonLongOutInput = input.text_area(DEF_JSON_OUT, "JSON · Long Exit", group = GRP_ALERT, tooltip = TIP_TEMPLATE) jsonShortOutInput = input.text_area(DEF_JSON_OUT, "JSON · Short Exit", group = GRP_ALERT, tooltip = TIP_TEMPLATE) textLongInInput = input.text_area(DEF_TEXT_LONG_IN, "Text · Long Entry", group = GRP_ALERT, tooltip = TIP_TEMPLATE) textShortInInput = input.text_area(DEF_TEXT_SHORT_IN, "Text · Short Entry", group = GRP_ALERT, tooltip = TIP_TEMPLATE) textLongOutInput = input.text_area(DEF_TEXT_LONG_OUT, "Text · Long Exit", group = GRP_ALERT, tooltip = TIP_TEMPLATE) textShortOutInput = input.text_area(DEF_TEXT_SHORT_OUT, "Text · Short Exit", group = GRP_ALERT, tooltip = TIP_TEMPLATE) showPreviewInput = input.bool(false, "Preview Messages in Pine Logs", group = GRP_ALERT, tooltip = "Writes all four messages to Pine Logs as they would be sent (values of the last historical bar), with the bot secret masked as ***. Use it to check a template without waiting for a signal.") // ── Colors ────────────────────────────────────── bullColorInput = input.color(#00E676, "Bull", inline = "colors", group = GRP_COLORS, tooltip = "Background of long entry labels, winning exit labels and winning trade boxes.") bearColorInput = input.color(#FF5252, "Bear", inline = "colors", group = GRP_COLORS, tooltip = "Background of short entry labels, losing exit labels and losing trade boxes.") rangeColorInput = input.color(#2962FF, "Range", inline = "colors", group = GRP_COLORS, tooltip = "Color of the daily range box, its boundaries and range labels.") // ══════════════════════════════════════════════════════════ // 4. THEME DETECTION & COLORS // ══════════════════════════════════════════════════════════ isDark = switch themeInput "Dark" => true "Light" => false => color.r(chart.bg_color) < 128 // Auto // ── Text ──────────────────────────────────────── TEXT_COLOR = isDark ? #E0E0E0 : #1A1A1A TEXT_MUTED = isDark ? color.new(#9E9E9E, 0) : color.new(#757575, 0) // ── Signal colors for text on the chart / table ─ BULL_TEXT = isDark ? #00E676 : #00A152 BEAR_TEXT = isDark ? #FF5252 : #D32F2F NEUTRAL_TEXT = isDark ? #FFEB3B : #F57F17 // ── Labels ────────────────────────────────────── BULL_LABEL_TEXT = #004D25 BEAR_LABEL_TEXT = #FFFFFF WARN_BG = #FFEB3B WARN_TEXT = #1A1A1A // ── Zones ─────────────────────────────────────── BULL_BG = color.new(bullColorInput, 85) BEAR_BG = color.new(bearColorInput, 85) RANGE_BG = color.new(rangeColorInput, 85) RANGE_BORDER = color.new(rangeColorInput, 40) // ── Dashboard ─────────────────────────────────── TABLE_BG = isDark ? color.new(#131722, 5) : color.new(#FFFFFF, 5) TABLE_BORDER = isDark ? color.new(#2A2E39, 0) : color.new(#D0D0D0, 0) TABLE_ROW_ALT = isDark ? color.new(#1C2030, 0) : color.new(#F0F4F8, 0) HEADER_BG = isDark ? color.new(#0D47A1, 0) : color.new(#1565C0, 0) HEADER_TEXT = #FFFFFF // ── Levels ────────────────────────────────────── SL_COLOR = color.new(#FF5252, 0) ENTRY_COLOR = color.new(#2962FF, 0) WM_COLOR = isDark ? color.new(#FFFFFF, 80) : color.new(#000000, 80) TRANSPARENT = color.new(#000000, 100) // ── Performance Chart ─────────────────────────── PERF_FILL_UP = color.new(BULL_TEXT, 82) PERF_FILL_DN = color.new(BEAR_TEXT, 82) labelSize = labelSizeInput == "Normal" ? size.normal : size.small dashSize = dashSizeInput == "Large" ? size.large : dashSizeInput == "Normal" ? size.normal : size.small dashPos = switch dashPosInput "Top Left" => position.top_left "Top Right" => position.top_right "Bottom Left" => position.bottom_left "Bottom Right" => position.bottom_right "Middle Right" => position.middle_right => position.top_right perfPos = switch perfPosInput "Bottom Left" => position.bottom_left "Bottom Center" => position.bottom_center "Bottom Right" => position.bottom_right "Middle Center" => position.middle_center "Top Left" => position.top_left "Top Center" => position.top_center => position.bottom_left // ── Broker time mode ──────────────────────────── bool useNy7 = tzModeInput == TZ_MODE_NY7 string calcTz = useNy7 ? "UTC" : tzInput string tzLabel = useNy7 ? "NY+7h" : tzInput // ── Instrument type ───────────────────────────── // Used only for size units (oz / units) and lot size in labels, dashboard and alerts. It does not restrict trading. string tickerUpper = str.upper(syminfo.ticker) string rootUpper = str.upper(syminfo.root) string prefixUpper = str.upper(syminfo.prefix) bool isFutures = syminfo.type == "futures" bool isXauName = str.contains(tickerUpper, "XAU") and not str.startswith(tickerUpper, "XAG") bool isGoldName = str.contains(tickerUpper, "GOLD") or str.contains(tickerUpper, "PAXG") or str.startswith(tickerUpper, "GLDRUB") bool isCmeRoot = isFutures and (rootUpper == "GC" or rootUpper == "MGC" or rootUpper == "1OZ" or rootUpper == "QO") bool isHkexRoot = isFutures and (rootUpper == "GDU" or rootUpper == "GDR") bool isShfeRoot = isFutures and rootUpper == "AU" and syminfo.currency == "CNY" bool isMoexRoot = isFutures and rootUpper == "GD" and (prefixUpper == "MOEX" or prefixUpper == "RUS") bool isSgeName = prefixUpper == "SGE" and (str.startswith(tickerUpper, "AU") or str.startswith(tickerUpper, "MAU")) bool isGold = isXauName or isGoldName or isCmeRoot or isHkexRoot or isShfeRoot or isMoexRoot or isSgeName bool isXagName = str.contains(tickerUpper, "XAG") bool isSilverName = str.contains(tickerUpper, "SILVER") or str.startswith(tickerUpper, "SLVRUB") bool isCmeSilver = isFutures and (rootUpper == "SIL" or rootUpper == "QI" or (rootUpper == "SI" and syminfo.currency == "USD")) bool isShfeSilver = isFutures and rootUpper == "AG" and syminfo.currency == "CNY" bool isMoexSilver = isFutures and (rootUpper == "SV" or rootUpper == "SILV") and (prefixUpper == "MOEX" or prefixUpper == "RUS") bool isSgeSilver = prefixUpper == "SGE" and str.startswith(tickerUpper, "AG") bool isSilver = not isGold and (isXagName or isSilverName or isCmeSilver or isShfeSilver or isMoexSilver or isSgeSilver) float lotOz = lotOzInput > 0 ? lotOzInput : isSilver ? 5000.0 : 100.0 bool isOunceGold = isXauName or str.contains(tickerUpper, "PAXG") or isCmeRoot or isMoexRoot or (str.contains(tickerUpper, "GOLD") and syminfo.currency == "USD") bool isOunceSilver = isSilver and (isXagName or isCmeSilver or isMoexSilver or (str.contains(tickerUpper, "SILVER") and syminfo.currency == "USD")) bool isOunceQuoted = isOunceGold or isOunceSilver string unitLabel = isOunceQuoted ? "oz" : "units" // ══════════════════════════════════════════════════════════ // 5. FUNCTIONS // ══════════════════════════════════════════════════════════ safeDiv(float num, float den, float fallback = 0.0) => den != 0 and not na(num) and not na(den) ? num / den : fallback // Rounds quantity down to the instrument step, so the planned risk never grows from rounding roundQtyDown(float qty, float step) => float q = math.max(nz(qty), 0.0) step > 0 ? math.floor(q / step + 1e-9) * step : q signedStr(float x, string fmt) => na(x) ? NO_VALUE : (x > 0 ? "+" : "") + str.tostring(x, fmt) priceStr(float x) => na(x) ? NO_VALUE : str.tostring(x, format.mintick) numStr(float x, string fmt) => na(x) ? NO_VALUE : str.tostring(x, fmt) maskSecret(string s) => secretInput == "" ? s : str.replace_all(s, secretInput, "***") // Fills an alert template. entryRef is the entry price the risk is measured from; tradeId is shared by the entry // and exit messages of one trade; equityRef is equity at entry, so {{risk_pct}} stays the initial risk. fillTemplate(string tpl, bool isLong, string event, string reason, float price, float entryRef, float sl, float qty, float rHigh, float rLow, string tradeId, float equityRef) => string s = "" if enableAlertsInput float oz = nz(qty) * syminfo.pointvalue float riskUsd = math.abs(nz(entryRef) - nz(sl)) * oz s := tpl s := str.replace_all(s, "{{ticker}}", syminfo.ticker) s := str.replace_all(s, "{{tickerid}}", syminfo.tickerid) s := str.replace_all(s, "{{exchange}}", syminfo.prefix) s := str.replace_all(s, "{{interval}}", timeframe.period) s := str.replace_all(s, "{{event}}", event) s := str.replace_all(s, "{{trade_id}}", tradeId) s := str.replace_all(s, "{{side}}", isLong ? "long" : "short") s := str.replace_all(s, "{{action}}", (event == "entry") == isLong ? "buy" : "sell") s := str.replace_all(s, "{{reason}}", reason) s := str.replace_all(s, "{{price}}", str.tostring(nz(price), format.mintick)) s := str.replace_all(s, "{{entry}}", str.tostring(nz(entryRef), format.mintick)) s := str.replace_all(s, "{{sl}}", str.tostring(nz(sl), format.mintick)) s := str.replace_all(s, "{{sl_pct}}", str.tostring(safeDiv(math.abs(nz(entryRef) - nz(sl)), entryRef) * 100.0, "0.####")) s := str.replace_all(s, "{{qty}}", str.tostring(nz(qty), "0.########")) s := str.replace_all(s, "{{oz}}", str.tostring(oz, "0.########")) s := str.replace_all(s, "{{lots}}", str.tostring(safeDiv(oz, lotOz), "0.########")) s := str.replace_all(s, "{{risk_usd}}", str.tostring(riskUsd, "0.00")) s := str.replace_all(s, "{{risk_pct}}", str.tostring(safeDiv(riskUsd, equityRef) * 100.0, "0.00")) s := str.replace_all(s, "{{equity}}", str.tostring(strategy.equity, "0.00")) s := str.replace_all(s, "{{range_high}}", str.tostring(nz(rHigh), format.mintick)) s := str.replace_all(s, "{{range_low}}", str.tostring(nz(rLow), format.mintick)) s := str.replace_all(s, "{{secret}}", secretInput) s // Broker server time. In "New York + 7h" mode: New York local time plus 7 hours (follows the US daylight-saving calendar) brokerClock(int t) => useNy7 ? timestamp("UTC", year(t, NY_TZ), month(t, NY_TZ), dayofmonth(t, NY_TZ), hour(t, NY_TZ), minute(t, NY_TZ), second(t, NY_TZ)) + NY7_SHIFT_MS : t // Row index (from the bottom) of a PnL value on the performance chart perfLevel(float v, float vMin, float span, int rows) => span > 0 ? math.round((v - vMin) / span * (rows - 1)) : 0 drawEntryLabel(bool isLong, float price, float sl, float qty) => label result = na if showEntryLabelsInput and not na(price) and not na(sl) float oz = nz(qty) * syminfo.pointvalue string txt = (isLong ? "▲ LONG" : "▼ SHORT") + "\nEntry " + priceStr(price) + "\nSL " + priceStr(sl) + " (" + str.tostring(safeDiv(math.abs(price - sl), price) * 100.0, "0.00") + "%)" + "\nSize " + str.tostring(oz, "0.####") + " " + unitLabel + (isOunceQuoted ? " · " + str.tostring(safeDiv(oz, lotOz), "0.####") + " lots" : "") + "\nRisk " + str.tostring(math.abs(price - sl) * oz, "0.00") + " " + syminfo.currency result := label.new(bar_index, price, txt, yloc = isLong ? yloc.belowbar : yloc.abovebar, style = isLong ? label.style_label_up : label.style_label_down, color = isLong ? bullColorInput : bearColorInput, textcolor = isLong ? BULL_LABEL_TEXT : BEAR_LABEL_TEXT, size = labelSize, textalign = text.align_left, tooltip = (isLong ? "Buy Signal" : "Sell Signal") + "\nReason: range breakout") result // Dashboard helpers: each returns the index of the next row dashHeader(table t, int r, string s) => table.cell(t, 0, r, s, text_color = HEADER_TEXT, bgcolor = HEADER_BG, text_size = dashSize, text_halign = text.align_center) table.merge_cells(t, 0, r, 1, r) r + 1 dashRow(table t, int r, string k, string v, color valueColor) => color rowBg = r % 2 == 0 ? TABLE_BG : TABLE_ROW_ALT table.cell(t, 0, r, k, text_color = TEXT_MUTED, bgcolor = rowBg, text_size = dashSize, text_halign = text.align_left) table.cell(t, 1, r, v, text_color = valueColor, bgcolor = rowBg, text_size = dashSize, text_halign = text.align_right) r + 1 // ══════════════════════════════════════════════════════════ // 6. CALCULATIONS // ══════════════════════════════════════════════════════════ // The strategy runs on bar close only, so the forming bar is never the "last" one while the market is open; // the last confirmed bar is used as well, otherwise tables would appear only after the next bar closes. bool isLastBar = barstate.islast or barstate.islastconfirmedhistory // The range is exact only when the timeframe divides an hour evenly; otherwise a warning is shown. // Trading is disabled only when the session hours are out of order. int tfSec = timeframe.in_seconds() bool tfOk = tfSec > 0 and tfSec <= 3600 and 3600 % tfSec == 0 bool hoursOk = rangeFromInput < rangeToInput and rangeToInput < closeHourInput bool envOk = hoursOk // ── Bar time (broker clock) ───────────────────── // nextHour is the hour of the next bar's open: orders placed now are filled on that bar. int barTime = brokerClock(time) int barHour = hour(barTime, calcTz) int nextHour = hour(brokerClock(time_close), calcTz) int dayKey = year(barTime, calcTz) * 10000 + month(barTime, calcTz) * 100 + dayofmonth(barTime, calcTz) bool isNewDay = dayKey != nz(dayKey[1], -1) bool inRange = barHour >= rangeFromInput and barHour < rangeToInput // ── Daily range ───────────────────────────────── var float rangeHigh = na var float rangeLow = na var int rangeStartBar = na var int tradedDay = -1 var bool isHalted = false var float dayEquityPeak = na var float slActiveLong = na var float slActiveShort = na // The first day of loaded history is skipped: its range may be incomplete var int firstDayKey = na if na(firstDayKey) firstDayKey := dayKey float prevEquity = nz(strategy.equity[1], strategy.equity) if isNewDay rangeHigh := na rangeLow := na rangeStartBar := na isHalted := false dayEquityPeak := prevEquity if inRange if na(rangeHigh) rangeStartBar := bar_index rangeHigh := na(rangeHigh) ? high : math.max(rangeHigh, high) rangeLow := na(rangeLow) ? low : math.min(rangeLow, low) bool rangeReady = not na(rangeHigh) and not na(rangeLow) and rangeHigh > rangeLow bool nextInWindow = nextHour >= rangeToInput and nextHour < closeHourInput // ── Position state ────────────────────────────── bool inPos = strategy.position_size != 0 bool posLong = strategy.position_size > 0 bool justOpened = inPos and strategy.position_size[1] == 0 if justOpened tradedDay := dayKey // one trade per day strategy.cancel("Long") strategy.cancel("Short") // In % mode the stop is re-set once from the actual fill price and then stays fixed if slModeInput == SL_MODE_PCT if posLong slActiveLong := math.round_to_mintick(strategy.position_avg_price * (1.0 - slPctInput / 100.0)) else slActiveShort := math.round_to_mintick(strategy.position_avg_price * (1.0 + slPctInput / 100.0)) // ── Closed-trade statistics ───────────────────── // R = trade result divided by its initial risk (entry to stop) var int seenClosed = 0 var int tradeCount = 0 var int winCount = 0 var int lossCount = 0 var float grossWin = 0.0 var float grossLoss = 0.0 var float sumR = 0.0 var int lossStreak = 0 var int maxLossStreak = 0 var float lastPnl = na var float lastR = na var array equityCurve = array.new() var float cumPnl = 0.0 var int firstTradeTime = na var int lastTradeTime = na int newClosedFrom = seenClosed int newClosedTo = strategy.closedtrades - 1 if newClosedTo >= newClosedFrom for i = newClosedFrom to newClosedTo float tSize = strategy.closedtrades.size(i) float tPnl = strategy.closedtrades.profit(i) float tEntry = strategy.closedtrades.entry_price(i) float tSl = tSize > 0 ? slActiveLong : slActiveShort float tRisk = strategy.convert_to_account(math.abs(tEntry - nz(tSl, tEntry)) * math.abs(tSize) * syminfo.pointvalue) float tR = tRisk > 0 ? tPnl / tRisk : na // Entry and exit inside one bar: the position is already flat at bar close, so count the day here if strategy.closedtrades.entry_bar_index(i) == strategy.closedtrades.exit_bar_index(i) tradedDay := dayKey tradeCount += 1 if tPnl > 0 winCount += 1 grossWin += tPnl lossStreak := 0 else if tPnl < 0 lossCount += 1 grossLoss += -tPnl lossStreak += 1 maxLossStreak := math.max(maxLossStreak, lossStreak) sumR += nz(tR) lastPnl := tPnl lastR := tR cumPnl += tPnl if showPerfInput array.push(equityCurve, cumPnl) if na(firstTradeTime) firstTradeTime := strategy.closedtrades.entry_time(i) lastTradeTime := strategy.closedtrades.exit_time(i) seenClosed := strategy.closedtrades // ── Equity drawdown (estimate) ────────────────── // Uses the worst point of each candle (low for longs, high for shorts) against the equity peak reached before // that candle. It is an estimate: the order of high and low inside a candle is unknown and the entry candle // is measured at its close only. var float equityHigh = strategy.initial_capital var float maxDdPct = 0.0 var float maxDdMoney = 0.0 float adverseMove = inPos and not justOpened ? (posLong ? close - low : high - close) : 0.0 float worstEquity = strategy.equity - strategy.convert_to_account(math.max(adverseMove, 0.0) * math.abs(strategy.position_size) * syminfo.pointvalue) maxDdPct := math.max(maxDdPct, safeDiv(equityHigh - worstEquity, equityHigh) * 100.0) maxDdMoney := math.max(maxDdMoney, equityHigh - worstEquity) equityHigh := math.max(equityHigh, strategy.equity) float dayDdPct = math.max(safeDiv(dayEquityPeak - worstEquity, dayEquityPeak) * 100.0, 0.0) dayEquityPeak := math.max(nz(dayEquityPeak, strategy.equity), strategy.equity) // ══════════════════════════════════════════════════════════ // 7. SIGNAL LOGIC // ══════════════════════════════════════════════════════════ // A breakout can be armed when the range is complete, the next bar opens inside the trading window, // there is no position and no trade has been taken today bool setupReady = envOk and rangeReady and nextInWindow and not inPos and tradedDay != dayKey and dayKey != firstDayKey // ══════════════════════════════════════════════════════════ // 8. RISK MANAGEMENT (SL / SIZE / GUARD) // ══════════════════════════════════════════════════════════ // Planned stop from the breakout level. Size = equity × risk% / (stop distance × point value), // capped by Max Leverage and rounded down to the quantity step. Equity is converted to the symbol currency. float slLong = slModeInput == SL_MODE_PCT ? math.round_to_mintick(rangeHigh * (1.0 - slPctInput / 100.0)) : rangeLow float slShort = slModeInput == SL_MODE_PCT ? math.round_to_mintick(rangeLow * (1.0 + slPctInput / 100.0)) : rangeHigh float riskLong = rangeHigh - slLong float riskShort = slShort - rangeLow float equitySym = strategy.convert_to_symbol(strategy.equity) float riskMoney = equitySym * riskPctInput / 100.0 float rawQtyLong = sizeModeInput == SIZE_FIXED ? fixedQtyInput : (riskLong > 0 ? safeDiv(riskMoney, riskLong * syminfo.pointvalue) : 0.0) float rawQtyShort = sizeModeInput == SIZE_FIXED ? fixedQtyInput : (riskShort > 0 ? safeDiv(riskMoney, riskShort * syminfo.pointvalue) : 0.0) float capQtyLong = math.max(safeDiv(equitySym * maxLeverageInput, rangeHigh * syminfo.pointvalue), 0.0) float capQtyShort = math.max(safeDiv(equitySym * maxLeverageInput, rangeLow * syminfo.pointvalue), 0.0) bool isCappedLong = rawQtyLong > capQtyLong bool isCappedShort = rawQtyShort > capQtyShort float qtyStep = qtyStepInput > 0 ? qtyStepInput : nz(syminfo.mincontract) float qtyLong = roundQtyDown(math.min(rawQtyLong, capQtyLong), qtyStep) float qtyShort = roundQtyDown(math.min(rawQtyShort, capQtyShort), qtyStep) string tplLongIn = webhookInput ? jsonLongInInput : textLongInInput string tplShortIn = webhookInput ? jsonShortInInput : textShortInInput string tplLongOut = webhookInput ? jsonLongOutInput : textLongOutInput string tplShortOut = webhookInput ? jsonShortOutInput : textShortOutInput string idPlan = syminfo.ticker + "-" + str.tostring(dayKey) string idOpen = syminfo.ticker + "-" + str.tostring(tradedDay) var float entryEquitySym = na // ── Equity guard ──────────────────────────────── // Pending orders are cancelled before the close order is created: cancel_all would remove that order too bool guardFired = false if guardOnInput and not isHalted and dayDdPct >= guardDdInput string guardMsg = inPos ? fillTemplate(posLong ? tplLongOut : tplShortOut, posLong, "exit", "equity_guard", close, strategy.position_avg_price, posLong ? slActiveLong : slActiveShort, math.abs(strategy.position_size), rangeHigh, rangeLow, idOpen, entryEquitySym) : "" strategy.cancel_all() strategy.close_all(comment = "Equity guard", alert_message = guardMsg) isHalted := true guardFired := true // ── Orders ────────────────────────────────────── // Both breakout entries share an OCA group: the first fill cancels the other. Each entry has its stop attached. bool canTrade = setupReady and not isHalted if canTrade slActiveLong := slLong slActiveShort := slShort entryEquitySym := equitySym if qtyLong > 0 and riskLong > 0 strategy.entry("Long", strategy.long, qty = qtyLong, stop = rangeHigh, oca_name = OCA_GROUP, oca_type = strategy.oca.cancel, comment = "RB long", alert_message = fillTemplate(tplLongIn, true, "entry", "breakout", rangeHigh, rangeHigh, slLong, qtyLong, rangeHigh, rangeLow, idPlan, equitySym)) strategy.exit("SL-L", from_entry = "Long", stop = slLong, comment = "SL", alert_message = fillTemplate(tplLongOut, true, "exit", "sl", slLong, rangeHigh, slLong, qtyLong, rangeHigh, rangeLow, idPlan, equitySym)) if qtyShort > 0 and riskShort > 0 strategy.entry("Short", strategy.short, qty = qtyShort, stop = rangeLow, oca_name = OCA_GROUP, oca_type = strategy.oca.cancel, comment = "RB short", alert_message = fillTemplate(tplShortIn, false, "entry", "breakout", rangeLow, rangeLow, slShort, qtyShort, rangeHigh, rangeLow, idPlan, equitySym)) strategy.exit("SL-S", from_entry = "Short", stop = slShort, comment = "SL", alert_message = fillTemplate(tplShortOut, false, "exit", "sl", slShort, rangeLow, slShort, qtyShort, rangeHigh, rangeLow, idPlan, equitySym)) else if not inPos strategy.cancel("Long") strategy.cancel("Short") // ── Open position ─────────────────────────────── // No alert is sent when the stop is re-set: a bot placing its own stop should use {{sl_pct}} from its own fill if inPos float posQty = math.abs(strategy.position_size) float posSl = posLong ? slActiveLong : slActiveShort string posTpl = posLong ? tplLongOut : tplShortOut float posEntry = strategy.position_avg_price if posLong strategy.exit("SL-L", from_entry = "Long", stop = slActiveLong, comment = "SL", alert_message = fillTemplate(posTpl, true, "exit", "sl", posSl, posEntry, posSl, posQty, rangeHigh, rangeLow, idOpen, entryEquitySym)) else strategy.exit("SL-S", from_entry = "Short", stop = slActiveShort, comment = "SL", alert_message = fillTemplate(posTpl, false, "exit", "sl", posSl, posEntry, posSl, posQty, rangeHigh, rangeLow, idOpen, entryEquitySym)) // Time exit: the close order is filled on the open of the next bar if (nextHour >= closeHourInput or nextHour < rangeToInput) and not guardFired strategy.close_all(comment = "Time exit " + str.tostring(closeHourInput) + ":00", alert_message = fillTemplate(posTpl, posLong, "exit", "time", close, posEntry, posSl, posQty, rangeHigh, rangeLow, idOpen, entryEquitySym)) // ══════════════════════════════════════════════════════════ // 9. PLOTS & VISUALS // ══════════════════════════════════════════════════════════ // Range box while the range is building, then its boundaries extended over the trading session var box rangeBox = na var line highLine = na var line lowLine = na if showRangeInput if isNewDay rangeBox := na highLine := na lowLine := na if inRange and not na(rangeHigh) if na(rangeBox) rangeBox := box.new(rangeStartBar, rangeHigh, bar_index, rangeLow, border_color = RANGE_BORDER, bgcolor = RANGE_BG) else box.set_top(rangeBox, rangeHigh) box.set_bottom(rangeBox, rangeLow) box.set_right(rangeBox, bar_index) if not inRange and rangeReady and barHour < closeHourInput if na(highLine) string widthStr = priceStr(rangeHigh - rangeLow) + " (" + str.tostring(safeDiv(rangeHigh - rangeLow, rangeLow) * 100.0, "0.00") + "%)" highLine := line.new(bar_index - 1, rangeHigh, bar_index, rangeHigh, color = rangeColorInput, width = 2) lowLine := line.new(bar_index - 1, rangeLow, bar_index, rangeLow, color = rangeColorInput, width = 2) label.new(bar_index, rangeHigh, "Range High " + priceStr(rangeHigh), style = label.style_label_down, color = rangeColorInput, textcolor = HEADER_TEXT, size = size.small) label.new(bar_index, rangeLow, "Range Low " + priceStr(rangeLow) + " · width " + widthStr, style = label.style_label_up, color = rangeColorInput, textcolor = HEADER_TEXT, size = size.small) else line.set_x2(highLine, bar_index) line.set_x2(lowLine, bar_index) // ══════════════════════════════════════════════════════════ // 10. LABELS & SHAPES // ══════════════════════════════════════════════════════════ // Entry label, then result label and trade box for every trade closed on this bar var int lastEntryBar = -1 if justOpened drawEntryLabel(posLong, strategy.position_avg_price, posLong ? slActiveLong : slActiveShort, math.abs(strategy.position_size)) lastEntryBar := bar_index if newClosedTo >= newClosedFrom for i = newClosedFrom to newClosedTo float cSize = strategy.closedtrades.size(i) bool cIsLong = cSize > 0 float cPnl = strategy.closedtrades.profit(i) float cEntry = strategy.closedtrades.entry_price(i) float cExit = strategy.closedtrades.exit_price(i) int cEntryBar = strategy.closedtrades.entry_bar_index(i) int cExitBar = strategy.closedtrades.exit_bar_index(i) string cComment = strategy.closedtrades.exit_comment(i) float cSl = cIsLong ? slActiveLong : slActiveShort float cRisk = strategy.convert_to_account(math.abs(cEntry - nz(cSl, cEntry)) * math.abs(cSize) * syminfo.pointvalue) float cR = cRisk > 0 ? cPnl / cRisk : na float cMovePct = safeDiv(cExit - cEntry, cEntry) * 100.0 * (cIsLong ? 1.0 : -1.0) bool cIsWin = cPnl >= 0 if cEntryBar == cExitBar and cEntryBar != lastEntryBar drawEntryLabel(cIsLong, cEntry, cSl, math.abs(cSize)) lastEntryBar := cEntryBar if showExitLabelsInput string cReason = cComment == "SL" ? "stop-loss" : str.startswith(cComment, "Time") ? "time exit " + str.tostring(closeHourInput) + ":00" : cComment == "Equity guard" ? "equity guard" : cComment string cRStr = na(cR) ? "" : signedStr(cR, "0.00") + "R · " string cText = (cIsWin ? "✔ " : "✖ ") + signedStr(cPnl, "0.00") + " " + strategy.account_currency + "\n" + cRStr + "move " + signedStr(cMovePct, "0.00") + "%\nExit " + priceStr(cExit) + "\n" + cReason label.new(cExitBar, cExit, cText, yloc = cIsLong ? yloc.abovebar : yloc.belowbar, style = cIsLong ? label.style_label_down : label.style_label_up, color = cIsWin ? bullColorInput : bearColorInput, textcolor = cIsWin ? BULL_LABEL_TEXT : BEAR_LABEL_TEXT, size = labelSize, textalign = text.align_left, tooltip = "Trade closed\nReason: " + cReason) if showTradeBoxInput box.new(cEntryBar, math.max(cEntry, cExit), cExitBar, math.min(cEntry, cExit), border_color = color.new(cIsWin ? bullColorInput : bearColorInput, 50), bgcolor = cIsWin ? BULL_BG : BEAR_BG) line.new(cEntryBar, cEntry, cExitBar, cExit, color = cIsWin ? BULL_TEXT : BEAR_TEXT, style = line.style_dotted, width = 1) // Warnings: wrong session hours disable trading; timeframe and chart type only affect range accuracy var label warnLabel = na if isLastBar string warnHours = not hoursOk ? "Trading is disabled:\n• Hours must satisfy: Range Start < Range End < Close Hour.\n" : "" string warnChart = not chart.is_standard ? "• Non-standard chart (Heikin Ashi, Renko…): the range is built from synthetic candles.\n" : "" string warnTf = not tfOk ? "• Timeframe above 1H or not dividing an hour evenly: candles cross the range window.\n" : "" string warnNote = showWarningsInput and (warnChart != "" or warnTf != "") ? "Range may be inaccurate:\n" + warnChart + warnTf : "" bool isSameCorner = showPerfInput and (showDashInput or showMathInput) and perfPosInput == dashPosInput string warnLayout = isSameCorner ? "Layout:\n• Dashboard and Performance Chart share the same corner: move one of them.\n" : "" string warnText = warnHours + warnNote + warnLayout if warnText != "" if na(warnLabel) warnLabel := label.new(bar_index, high, warnText, style = label.style_label_down, color = WARN_BG, textcolor = WARN_TEXT, size = size.small, textalign = text.align_left) else label.set_xy(warnLabel, bar_index, high) // ══════════════════════════════════════════════════════════ // 11. SL / ENTRY LINES // ══════════════════════════════════════════════════════════ bool showLevels = showSlInput and inPos entryPlot = plot(showLevels ? strategy.position_avg_price : na, "Entry Price", color = ENTRY_COLOR, style = plot.style_linebr, linewidth = 1) slPlot = plot(showLevels ? (posLong ? slActiveLong : slActiveShort) : na, "Stop-Loss", color = SL_COLOR, style = plot.style_linebr, linewidth = 2) fill(entryPlot, slPlot, color = color.new(#FF5252, 88), title = "Risk Zone") // ══════════════════════════════════════════════════════════ // 12. DASHBOARD // ══════════════════════════════════════════════════════════ var table dashTable = table.new( position = dashPos, columns = 2, rows = 40, bgcolor = TABLE_BG, border_color = TABLE_BORDER, border_width = 1, frame_color = TABLE_BORDER, frame_width = 1) if isLastBar and (showDashInput or showMathInput) int row = 0 string cur = " " + strategy.account_currency string symCur = " " + syminfo.currency if showDashInput string trendStr = not rangeReady ? NO_VALUE : close > rangeHigh ? "Bullish (above range)" : close < rangeLow ? "Bearish (below range)" : "Neutral (inside range)" color trendColor = not rangeReady ? TEXT_COLOR : close > rangeHigh ? BULL_TEXT : close < rangeLow ? BEAR_TEXT : NEUTRAL_TEXT string disabledStr = "Disabled (check hours)" string signalStr = not envOk ? disabledStr : isHalted ? "Halted: equity guard" : inPos ? (posLong ? "Long" : "Short") : inRange ? "Building range" : tradedDay == dayKey ? "Done for today" : rangeReady and barHour >= rangeToInput and barHour < closeHourInput ? "Wait breakout" : "Outside session" color signalColor = inPos ? (posLong ? BULL_TEXT : BEAR_TEXT) : isHalted or not envOk ? BEAR_TEXT : TEXT_COLOR string widthStr = rangeReady ? priceStr(rangeHigh - rangeLow) + " (" + str.tostring(safeDiv(rangeHigh - rangeLow, rangeLow) * 100.0, "0.00") + "%)" : NO_VALUE row := dashHeader(dashTable, row, "Gold Breakout 15M · " + syminfo.ticker) row := dashRow(dashTable, row, "Trend", trendStr, trendColor) row := dashRow(dashTable, row, "Signal", signalStr, signalColor) row := dashRow(dashTable, row, "Timeframe", timeframe.period + " · " + tzLabel, TEXT_COLOR) row := dashRow(dashTable, row, "Session", str.tostring(rangeToInput) + ":00 – " + str.tostring(closeHourInput) + ":00", TEXT_COLOR) row := dashRow(dashTable, row, "Range", rangeReady ? priceStr(rangeLow) + " – " + priceStr(rangeHigh) : NO_VALUE, TEXT_COLOR) row := dashRow(dashTable, row, "Range width", widthStr, TEXT_COLOR) float openRisk = inPos ? strategy.convert_to_account(math.abs(strategy.position_avg_price - nz(posLong ? slActiveLong : slActiveShort, strategy.position_avg_price)) * math.abs(strategy.position_size) * syminfo.pointvalue) : 0.0 string openRStr = openRisk > 0 ? " · " + signedStr(strategy.openprofit / openRisk, "0.00") + "R" : "" string openStr = inPos ? signedStr(strategy.openprofit, "0.00") + cur + openRStr : NO_VALUE row := dashRow(dashTable, row, "Open P&L", openStr, not inPos ? TEXT_COLOR : strategy.openprofit >= 0 ? BULL_TEXT : BEAR_TEXT) row := dashRow(dashTable, row, "Day drawdown (est.)", str.tostring(dayDdPct, "0.00") + "%", guardOnInput and dayDdPct >= guardDdInput ? BEAR_TEXT : TEXT_COLOR) float ozLong = nz(qtyLong) * syminfo.pointvalue float ozShort = nz(qtyShort) * syminfo.pointvalue float slPctLong = safeDiv(riskLong, rangeHigh) * 100.0 float slPctShort = safeDiv(riskShort, rangeLow) * 100.0 float slPctMax = math.max(slPctLong, slPctShort) color riskColor = slPctMax > 3.0 ? BEAR_TEXT : slPctMax > 1.0 ? NEUTRAL_TEXT : BULL_TEXT string slStr = rangeReady ? priceStr(slLong) + " / " + priceStr(slShort) : NO_VALUE string distStr = rangeReady ? priceStr(riskLong) + " / " + priceStr(riskShort) : NO_VALUE string riskPctStr = rangeReady ? str.tostring(slPctLong, "0.00") + "% / " + str.tostring(slPctShort, "0.00") + "%" : NO_VALUE string riskUsdStr = rangeReady ? str.tostring(riskLong * ozLong, "0.00") + " / " + str.tostring(riskShort * ozShort, "0.00") + symCur : NO_VALUE string ozStr = rangeReady ? str.tostring(ozLong, "0.####") + " / " + str.tostring(ozShort, "0.####") : NO_VALUE string lotsStr = rangeReady and isOunceQuoted ? str.tostring(safeDiv(ozLong, lotOz), "0.####") + " / " + str.tostring(safeDiv(ozShort, lotOz), "0.####") : NO_VALUE string notionalStr = rangeReady ? str.tostring(ozLong * rangeHigh, "0") + " / " + str.tostring(ozShort * rangeLow, "0") + symCur : NO_VALUE string leverageStr = rangeReady ? "×" + str.tostring(safeDiv(ozLong * rangeHigh, equitySym), "0.00") + " / ×" + str.tostring(safeDiv(ozShort * rangeLow, equitySym), "0.00") : NO_VALUE row := dashHeader(dashTable, row, "Position Plan · current range (long / short)") row := dashRow(dashTable, row, "SL", slStr, SL_COLOR) row := dashRow(dashTable, row, "SL distance", distStr, TEXT_COLOR) row := dashRow(dashTable, row, "SL distance, % of price", riskPctStr, rangeReady ? riskColor : TEXT_COLOR) row := dashRow(dashTable, row, "Risk amount", riskUsdStr, TEXT_COLOR) row := dashRow(dashTable, row, "Size, " + unitLabel, ozStr, TEXT_COLOR) row := dashRow(dashTable, row, "Size, lots", lotsStr, TEXT_COLOR) row := dashRow(dashTable, row, "Notional", notionalStr, TEXT_COLOR) row := dashRow(dashTable, row, "Leverage vs equity", leverageStr, TEXT_COLOR) bool isBelowStep = rangeReady and (qtyLong <= 0 or qtyShort <= 0) bool isCapped = rangeReady and (isCappedLong or isCappedShort) string limitStr = not rangeReady ? NO_VALUE : isBelowStep ? "Below min step: side skipped" : isCapped ? "Capped by max leverage" : "OK" color limitColor = not rangeReady ? TEXT_COLOR : isBelowStep ? BEAR_TEXT : isCapped ? NEUTRAL_TEXT : BULL_TEXT row := dashRow(dashTable, row, "Size limits", limitStr, limitColor) if showMathInput float winRate = tradeCount > 0 ? 100.0 * winCount / tradeCount : na float avgWin = winCount > 0 ? grossWin / winCount : na float avgLoss = lossCount > 0 ? grossLoss / lossCount : na float payoff = not na(avgWin) and not na(avgLoss) and avgLoss > 0 ? avgWin / avgLoss : na float profitFactor = grossLoss > 0 ? grossWin / grossLoss : na float expectancy = tradeCount > 0 ? (grossWin - grossLoss) / tradeCount : na float expectancyR = tradeCount > 0 ? sumR / tradeCount : na float breakevenWr = not na(payoff) ? 100.0 / (1.0 + payoff) : na float netPct = safeDiv(strategy.netprofit, strategy.initial_capital) * 100.0 string tradesStr = str.tostring(tradeCount) + " (" + str.tostring(winCount) + " / " + str.tostring(lossCount) + ")" string avgStr = numStr(avgWin, "0.00") + " / " + numStr(avgLoss, "0.00") + cur string expStr = na(expectancy) ? NO_VALUE : signedStr(expectancy, "0.00") + cur + " · " + signedStr(expectancyR, "0.00") + "R" string netStr = signedStr(strategy.netprofit, "0.00") + cur + " (" + signedStr(netPct, "0.00") + "%)" string lastStr = na(lastPnl) ? NO_VALUE : signedStr(lastPnl, "0.00") + cur + (na(lastR) ? "" : " · " + signedStr(lastR, "0.00") + "R") color wrColor = na(breakevenWr) or na(winRate) ? TEXT_COLOR : winRate >= breakevenWr ? BULL_TEXT : BEAR_TEXT color pfColor = na(profitFactor) ? TEXT_COLOR : profitFactor >= 1 ? BULL_TEXT : BEAR_TEXT color expColor = na(expectancy) ? TEXT_COLOR : expectancy >= 0 ? BULL_TEXT : BEAR_TEXT color lastColor = na(lastPnl) ? TEXT_COLOR : lastPnl >= 0 ? BULL_TEXT : BEAR_TEXT row := dashHeader(dashTable, row, "Strategy Math") row := dashRow(dashTable, row, "Trades (win / loss)", tradesStr, TEXT_COLOR) row := dashRow(dashTable, row, "Win rate", na(winRate) ? NO_VALUE : str.tostring(winRate, "0.0") + "%", wrColor) row := dashRow(dashTable, row, "Breakeven win rate", na(breakevenWr) ? NO_VALUE : str.tostring(breakevenWr, "0.0") + "%", TEXT_COLOR) row := dashRow(dashTable, row, "Profit factor", numStr(profitFactor, "0.00"), pfColor) row := dashRow(dashTable, row, "Avg win / avg loss", avgStr, TEXT_COLOR) row := dashRow(dashTable, row, "Payoff (win ÷ loss)", numStr(payoff, "0.00"), TEXT_COLOR) row := dashRow(dashTable, row, "Expectancy per trade", expStr, expColor) row := dashRow(dashTable, row, "Net profit", netStr, strategy.netprofit >= 0 ? BULL_TEXT : BEAR_TEXT) row := dashRow(dashTable, row, "Max equity drawdown (est.)", str.tostring(maxDdPct, "0.00") + "%", TEXT_COLOR) row := dashRow(dashTable, row, "Max losing streak", str.tostring(maxLossStreak), TEXT_COLOR) row := dashRow(dashTable, row, "Last trade", lastStr, lastColor) table.cell(dashTable, 0, row, "Version", text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.tiny, text_halign = text.align_left) table.cell(dashTable, 1, row, STRATEGY_VERSION, text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.tiny, text_halign = text.align_right) // ══════════════════════════════════════════════════════════ // 12b. PERFORMANCE CHART // ══════════════════════════════════════════════════════════ // Cumulative PnL of closed trades, drawn with table cells so it stays fixed on screen. // X axis is the trade number; each column spans the lowest and highest PnL of its trades. // It covers the bars loaded on the chart, not the Deep Backtesting range. Redrawn only after a new closed trade. var table perfTable = na var bool perfMerged = false var int perfDrawnCount = -1 if isLastBar and showPerfInput int pCols = perfColsInput int pRows = perfRowsInput int pTop = 3 int pDates = pRows + pTop if na(perfTable) perfTable := table.new( position = perfPos, columns = pCols + 1, rows = pRows + pTop + 1, bgcolor = TABLE_BG, border_color = TRANSPARENT, border_width = 0, frame_color = TABLE_BORDER, frame_width = 1) // ── Key stats ─────────────────────────────── string pCur = " " + strategy.account_currency float pNetPct = safeDiv(strategy.netprofit, strategy.initial_capital) * 100.0 float pWinRate = tradeCount > 0 ? 100.0 * winCount / tradeCount : na float pPf = grossLoss > 0 ? grossWin / grossLoss : na string pPnlStr = signedStr(strategy.netprofit, "#,##0.00") + pCur + " " + signedStr(pNetPct, "0.00") + "%" string pDdStr = str.tostring(maxDdMoney, "#,##0.00") + pCur + " " + str.tostring(maxDdPct, "0.00") + "%" string pWinStr = (na(pWinRate) ? NO_VALUE : str.tostring(pWinRate, "0.00") + "%") + " " + str.tostring(winCount) + "/" + str.tostring(tradeCount) string pPfStr = numStr(pPf, "0.000") color pPnlColor = strategy.netprofit >= 0 ? BULL_TEXT : BEAR_TEXT int pBlock = int(pCols / 4) table.cell(perfTable, 0, 0, "Key stats · Cumulative PnL · " + syminfo.ticker + " " + timeframe.period, text_color = HEADER_TEXT, bgcolor = HEADER_BG, text_size = size.small, text_halign = text.align_left) table.cell(perfTable, 0, 1, "Total PnL", text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_left) table.cell(perfTable, pBlock, 1, "Max drawdown", text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_left) table.cell(perfTable, pBlock * 2, 1, "Profitable trades", text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_left) table.cell(perfTable, pBlock * 3, 1, "Profit factor", text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_left) table.cell(perfTable, 0, 2, pPnlStr, text_color = pPnlColor, bgcolor = TABLE_BG, text_size = size.normal, text_halign = text.align_left) table.cell(perfTable, pBlock, 2, pDdStr, text_color = TEXT_COLOR, bgcolor = TABLE_BG, text_size = size.normal, text_halign = text.align_left) table.cell(perfTable, pBlock * 2, 2, pWinStr, text_color = TEXT_COLOR, bgcolor = TABLE_BG, text_size = size.normal, text_halign = text.align_left) table.cell(perfTable, pBlock * 3, 2, pPfStr, text_color = TEXT_COLOR, bgcolor = TABLE_BG, text_size = size.normal, text_halign = text.align_left) int pMid = int(pRows / 2) int pHalf = int(pCols / 2) int pCount = array.size(equityCurve) if pCount != perfDrawnCount int pPts = pCount + 1 float pMax = pCount > 0 ? math.max(array.max(equityCurve), 0.0) : 0.0 float pMin = pCount > 0 ? math.min(array.min(equityCurve), 0.0) : 0.0 float pSpan = pMax - pMin int pZero = perfLevel(0.0, pMin, pSpan, pRows) float pCellW = perfWidthInput / pCols float pCellH = perfHeightInput / pRows int pPrevIdx = -1 int pPrevLevel = pZero for c = 0 to pCols - 1 int pIdx = math.round(1.0 * c * (pPts - 1) / (pCols - 1)) float pVal = pIdx == 0 ? 0.0 : array.get(equityCurve, pIdx - 1) float pBMin = pVal float pBMax = pVal if pIdx - pPrevIdx > 1 for k = pPrevIdx + 1 to pIdx - 1 float pMidVal = k == 0 ? 0.0 : array.get(equityCurve, k - 1) pBMin := math.min(pBMin, pMidVal) pBMax := math.max(pBMax, pMidVal) int pLevel = perfLevel(pVal, pMin, pSpan, pRows) int pLineLo = math.min(perfLevel(pBMin, pMin, pSpan, pRows), pPrevLevel) int pLineHi = math.max(perfLevel(pBMax, pMin, pSpan, pRows), pPrevLevel) for r = 0 to pRows - 1 int pH = pRows - 1 - r bool pIsLine = pH >= pLineLo and pH <= pLineHi color pColor = pIsLine ? (pVal >= 0 ? BULL_TEXT : BEAR_TEXT) : (pH >= pZero and pH < pLineLo) ? PERF_FILL_UP : (pH <= pZero and pH > pLineHi) ? PERF_FILL_DN : TRANSPARENT table.cell(perfTable, c, r + pTop, "", width = pCellW, height = pCellH, bgcolor = pColor, text_size = size.tiny) pPrevIdx := pIdx pPrevLevel := pLevel string pMaxStr = signedStr(pMax, "#,##0") string pMinStr = signedStr(pMin, "#,##0") table.cell(perfTable, pCols, pTop, pMaxStr, text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_left, text_valign = text.align_top) table.cell(perfTable, pCols, pTop + pMid, pMinStr, text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_left, text_valign = text.align_bottom) perfDrawnCount := pCount string pFromStr = na(firstTradeTime) ? "No closed trades yet" : str.format_time(firstTradeTime, "yyyy-MM-dd", syminfo.timezone) + " · closed trades, x = trade #" string pToStr = na(lastTradeTime) ? "" : str.format_time(lastTradeTime, "yyyy-MM-dd", syminfo.timezone) table.cell(perfTable, 0, pDates, pFromStr, text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_left) table.cell(perfTable, pHalf, pDates, pToStr, text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_right) if not perfMerged table.merge_cells(perfTable, 0, 0, pCols, 0) table.merge_cells(perfTable, 0, 1, pBlock - 1, 1) table.merge_cells(perfTable, pBlock, 1, pBlock * 2 - 1, 1) table.merge_cells(perfTable, pBlock * 2, 1, pBlock * 3 - 1, 1) table.merge_cells(perfTable, pBlock * 3, 1, pCols, 1) table.merge_cells(perfTable, 0, 2, pBlock - 1, 2) table.merge_cells(perfTable, pBlock, 2, pBlock * 2 - 1, 2) table.merge_cells(perfTable, pBlock * 2, 2, pBlock * 3 - 1, 2) table.merge_cells(perfTable, pBlock * 3, 2, pCols, 2) table.merge_cells(perfTable, pCols, pTop, pCols, pTop + pMid - 1) table.merge_cells(perfTable, pCols, pTop + pMid, pCols, pTop + pRows - 1) table.merge_cells(perfTable, 0, pDates, pHalf - 1, pDates) table.merge_cells(perfTable, pHalf, pDates, pCols, pDates) perfMerged := true // ══════════════════════════════════════════════════════════ // 13. WATERMARK // ══════════════════════════════════════════════════════════ bool isWmBlocked = showPerfInput and perfPosInput == "Bottom Center" if isLastBar and showWatermarkInput and not isWmBlocked var wmTable = table.new( position = position.bottom_center, columns = 1, rows = 1, bgcolor = TRANSPARENT, border_color = TRANSPARENT, border_width = 0, frame_color = TRANSPARENT, frame_width = 0) table.cell(wmTable, 0, 0, "WillyAlgoTrader", text_color = WM_COLOR, text_size = size.normal, text_halign = text.align_center, bgcolor = TRANSPARENT) // ══════════════════════════════════════════════════════════ // 14. ALERTS // ══════════════════════════════════════════════════════════ // Alert messages are attached to the orders in section 8 and are sent when an order is filled. // This block only previews the four templates in Pine Logs. if showPreviewInput and barstate.islastconfirmedhistory float pvHigh = nz(rangeHigh, close) float pvLow = nz(rangeLow, close) float pvSlL = nz(slLong, pvHigh * 0.99) float pvSlS = nz(slShort, pvLow * 1.01) log.info("LONG ENTRY → " + maskSecret(fillTemplate(tplLongIn, true, "entry", "breakout", pvHigh, pvHigh, pvSlL, nz(qtyLong, 1.0), pvHigh, pvLow, idPlan, equitySym))) log.info("SHORT ENTRY → " + maskSecret(fillTemplate(tplShortIn, false, "entry", "breakout", pvLow, pvLow, pvSlS, nz(qtyShort, 1.0), pvHigh, pvLow, idPlan, equitySym))) log.info("LONG EXIT → " + maskSecret(fillTemplate(tplLongOut, true, "exit", "time", close, pvHigh, pvSlL, nz(qtyLong, 1.0), pvHigh, pvLow, idPlan, equitySym))) log.info("SHORT EXIT → " + maskSecret(fillTemplate(tplShortOut, false, "exit", "time", close, pvLow, pvSlS, nz(qtyShort, 1.0), pvHigh, pvLow, idPlan, equitySym)))
cryptidcodex-archive Verified groups, channels and servers

Gold Signals - Forex Trading

Finding reliable market discussion on YouTube can take hours of searching. The Gold Signals Forex Trading channel operates on the public video platform, focusing its content on stocks. Because it is hosted on a free video sharing service, anyone with an internet connection can access the videos without a subscription fee. This accessibility makes it an easy stop for people looking for ideas about the stock market, though it also means viewers must approach every upload with a critical eye.

Understanding the Scope and Focus

The first detail many observers notice is the contrast between the name and the listed topic. The title mentions both gold and forex, yet the specific subject matter for this listing is stocks. In online trading spaces, creators sometimes select general names to capture search traffic across multiple asset classes, or they expand their coverage after starting with currency pairs and precious metals. Regardless of the name, users coming to this space should expect stock market content rather than an exclusive focus on bullion or foreign exchange.

Video formats on YouTube generally allow creators to share charts, talk through technical patterns, and point out price targets. Viewers can see where an analyst draws support levels, resistance lines, or trend indicators. Because it is a video channel rather than a private chat group, you receive commentary in long form rather than quick, time sensitive alert pings. This format works well for conceptual learning, but it creates a natural delay between the moment an idea forms and the moment you see it.

Posting Schedules and Publication Habits

A central question for any trader is how frequently content arrives. In this case, an official posting schedule is not published. Some creators upload multiple times each week to react to earnings reports and daily market sessions, while others post only when they spot a clear setup or when broad index movements catch their attention.

Because release dates and times are not formally documented, viewers should not build their daily routines around guaranteed morning or evening updates. You cannot treat an unmetered video feed like an execution desk. Market prices move constantly during regular exchange hours. By the time a video is recorded, rendered, uploaded, and processed by YouTube, the opening price or the initial entry window for a stock setup may have already passed. Anyone using public videos as part of their routine needs to recognize this built-in lag.

Who This Channel May Suit

This channel is best suited for independent learners who want to see how another person looks at equity charts. If you are someone who likes collecting different viewpoints before forming your own opinion, watching stock analysis videos can provide useful perspective. It gives you an opportunity to compare your charting style against another trader.

It also suits people who prefer visual and spoken explanations over text alerts. Reading a message that lists an entry, a stop, and a target does not teach you why those levels were chosen. A video Walkthrough on YouTube shows the chart directly, which helps visual learners understand common patterns, moving averages, and general price action. If you treat the videos as supplementary study material rather than instructions, the content can serve a constructive purpose.

Who Should Stay Away

This channel is not appropriate for day traders who need immediate, split second execution. If your strategy relies on capturing fast swings within minutes of the market open, static video uploads will not help you. Relying on YouTube for rapid execution leads to late entries and poor risk management.

People who want passive income or who expect someone else to manage their financial decisions should also stay away. Following trade ideas blindly is one of the fastest ways to lose capital in the equity markets. If you do not know how to calculate position size, manage downside risk, or cut a losing trade on your own, watching trading videos will only create an illusion of confidence. Anyone looking for audited performance records, verified track records, or certified financial advice will not find that here, as public channels do not provide third party verification.

The Nature of Market Risk

Trading stocks carries a persistent risk of financial loss. Share prices fluctuate based on company earnings, macroeconomic reports, interest rate decisions, and unpredictable news events. No chart pattern works every time. Even the most carefully planned stock setup can fail immediately if market sentiment turns negative.

Because YouTube commentary is free and accessible, it is easy to forget that real capital is on the line. When an analyst on a screen speaks with confidence, it can sound as though an outcome is certain. It is not. Every trade involves the possibility of losing money. Viewers must decide their own risk tolerance before placing any trade, and they should never allocate money they cannot afford to lose.

How to Use This Content Responsibly

If you decide to spend time on this channel, the safest approach is to treat each video as a case study. Open your own charting software alongside the video. Verify the stock ticker, check the current volume, examine the broader trend, and see whether you agree with the logic being presented.

Never enter an order simply because a video title or thumbnail highlighted a specific stock. Track the ideas on paper first. By paper trading the setups over several weeks, you can observe whether the analysis matches real market outcomes without putting your personal savings at risk. Independent verification is the single most important habit any retail trader can develop.

Verdict: Treat it as visual study material for stock charts, not as direct trading advice.

Questions people ask

What markets does this channel actually cover?

Although the title includes Gold and Forex, the channel subject is listed as stocks. Viewers should expect content centered on equity markets rather than currencies.

How often does the channel publish new videos?

An official upload schedule is not published. Video frequency depends entirely on when the creator decides to post, so updates may be irregular.

Does the channel provide verified trading results?

No verified track record or audited performance history is published. Any past setups shown in videos should be viewed as unverified claims.

Can beginners use these videos to execute real trades?

Beginners should not execute live trades based on YouTube videos. Due to upload delays and market volatility, following video ideas without independent risk management carries a high risk of loss.

Before you subscribe to anything: no channel can promise you a result. Check the link, check the member count, and never send money to an admin who messages you first.

Been in this group?

Tell people what actually happened. Honest reports only, no affiliate links and no invented screenshots.

Comments