IQ_WIKI_BINARY_SIGNAL_GUN_V1.1.0

The download and this preview resolve to the same reviewed file. SHA-256: eff4e7b1ce463aa2d5a96a7bf75e5b800dbdd916c59a3e347029dff443fbe9b1

-- SPDX-License-Identifier: MIT
-- IQOptionWiki QCS Library
-- IQ_WIKI_BINARY_SIGNAL_GUN_V1.1.0
--
-- Local, completed-candle adaptation of the iqoptionwiki.com Binary Signal
-- Gun. It keeps the source engine's four-family weighted confluence model:
-- RSI, MACD, Bollinger Bands, and candlestick patterns.
--
-- Deliberate V1.1 corrections:
--   * Only the previous completed IQ Option candle can qualify.
--   * MACD histogram strength is normalized by ATR across price scales.
--   * ATR risk changes confidence once (the web engine applies it twice).
--   * Strategy boosts must agree with the confluence direction.
--   * Session bonuses, provider caches, API data, wall-clock expiry, and
--     reported website win rates are not imported into this indicator.
--   * A new setup transition produces one marker/advice pulse.
--
-- "Strength" is an internal confluence score, not a win probability.
-- CALL/PUT markers are analysis aids, not orders or outcome guarantees.

instrument {
    name = "IQ_WIKI_BINARY_SIGNAL_GUN_V1.1.0",
    short_name = "IQ WIKI SIGNAL GUN",
    icon = "indicators:MACD",
    overlay = true
}

input_group {
    "1. Signal Gun indicators",
    rsi_period = input (14, "RSI period", input.integer, 2, 100),
    macd_fast_period = input (12, "MACD fast EMA", input.integer, 2, 100),
    macd_slow_period = input (26, "MACD slow EMA", input.integer, 3, 200),
    macd_signal_period = input (9, "MACD signal EMA", input.integer, 2, 100),
    bollinger_period = input (20, "Bollinger period", input.integer, 5, 200),
    bollinger_deviation = input (2.0, "Bollinger deviations", input.double, 0.5, 5.0, 0.1, false),
    atr_period = input (14, "ATR period", input.integer, 2, 100)
}

input_group {
    "2. Scale-safe MACD",
    macd_moderate_atr = input (0.05, "Moderate histogram / ATR", input.double, 0.01, 2.00, 0.01, false),
    macd_strong_atr = input (0.15, "Strong histogram / ATR", input.double, 0.02, 3.00, 0.01, false)
}

input_group {
    "3. Confluence and risk",
    minimum_strength = input (65, "Minimum confluence strength", input.integer, 40, 95),
    minimum_agreeing_families = input (2, "Minimum agreeing families", input.integer, 2, 4),
    low_atr_percent = input (0.15, "Low ATR / price (%)", input.double, 0.01, 5.00, 0.01, false),
    high_atr_percent = input (0.40, "High ATR / price (%)", input.double, 0.02, 10.00, 0.01, false)
}

input_group {
    "4. Display and advice",
    bands_visible = input { default = true, name = "Show Bollinger Bands", type = input.plot_visibility },
    signals_visible = input { default = true, name = "Show completed-candle signals", type = input.plot_visibility },
    advice_enabled = input { default = false, name = "Enable platform advice", type = input.boolean }
}

input_group {
    "Band colors",
    upper_band_color = input { default = rgba(255, 177, 90, 0.45), type = input.color },
    middle_band_color = input { default = rgba(255, 255, 255, 0.28), type = input.color },
    lower_band_color = input { default = rgba(86, 206, 255, 0.45), type = input.color },
    band_width = input { default = 1, type = input.line_width }
}

input_group {
    "Signal colors",
    call_color = input { default = "#25E154", type = input.color },
    put_color = input { default = "#FF6C58", type = input.color },
    elite_call_color = input { default = "#56CEFF", type = input.color },
    elite_put_color = input { default = "#FFB15A", type = input.color },
    signal_text_color = input { default = "#FFFFFF", type = input.color }
}

-- Indicator series on the active IQ Option chart.
rsi_value = rsi (close, rsi_period)

macd_fast = ema (close, macd_fast_period)
macd_slow = ema (close, macd_slow_period)
macd_line = macd_fast - macd_slow
macd_signal = ema (macd_line, macd_signal_period)
macd_histogram = macd_line - macd_signal

bollinger_middle = sma (close, bollinger_period)
-- QCS stdev() uses sample deviation; the Signal Gun service uses population
-- deviation. This correction keeps the same Bollinger-band definition.
bollinger_population_factor = math.sqrt ((bollinger_period - 1) / bollinger_period)
bollinger_spread =
    stdev (close, bollinger_period) *
    bollinger_population_factor *
    bollinger_deviation
bollinger_upper = bollinger_middle + bollinger_spread
bollinger_lower = bollinger_middle - bollinger_spread

atr_value = rma (tr, atr_period)
atr_safe = max (atr_value, 0.0000000001)
macd_histogram_atr = abs (macd_histogram) / atr_safe

-- Scalar values are required for native Lua branches.
local close_now = get_value (close, 0)
local open_now = get_value (open, 0)
local high_now = get_value (high, 0)
local low_now = get_value (low, 0)
local previous_close = get_value (close [1], 0)
local previous_open = get_value (open [1], 0)
local first_close = get_value (close [2], 0)
local first_open = get_value (open [2], 0)

local rsi_now = get_value (rsi_value, 50)
local macd_histogram_now = get_value (macd_histogram, 0)
local macd_histogram_atr_now = get_value (macd_histogram_atr, 0)
local upper_now = get_value (bollinger_upper, 0)
local middle_now = get_value (bollinger_middle, 0)
local lower_now = get_value (bollinger_lower, 0)
local atr_now = get_value (atr_value, 0)

local warmup_index =
    math.max (
        rsi_period + 1,
        macd_slow_period + macd_signal_period,
        bollinger_period,
        atr_period
    )
local warmup_close = get_value (close [warmup_index], 0)

local periods_are_valid =
    macd_fast_period < macd_slow_period and
    bollinger_deviation > 0 and
    macd_moderate_atr > 0 and
    macd_strong_atr > macd_moderate_atr and
    minimum_agreeing_families >= 2 and
    minimum_agreeing_families <= 4 and
    low_atr_percent > 0 and
    high_atr_percent > low_atr_percent

local data_is_ready =
    periods_are_valid and
    warmup_close > 0 and
    close_now > 0 and
    high_now >= low_now and
    atr_now > 0 and
    upper_now > lower_now and
    middle_now > 0

-- Source-compatible candle-pattern family.
local current_range = high_now - low_now
local current_body = math.abs (close_now - open_now)
local previous_body = math.abs (previous_close - previous_open)
local first_body = math.abs (first_close - first_open)

local current_bullish = close_now > open_now
local current_bearish = close_now < open_now
local previous_bullish = previous_close > previous_open
local previous_bearish = previous_close < previous_open

local bullish_engulfing =
    previous_bearish and
    current_bullish and
    open_now <= previous_close and
    close_now >= previous_open

local bearish_engulfing =
    previous_bullish and
    current_bearish and
    open_now >= previous_close and
    close_now <= previous_open

local current_body_low = math.min (open_now, close_now)
local current_body_high = math.max (open_now, close_now)
local previous_body_low = math.min (previous_open, previous_close)
local previous_body_high = math.max (previous_open, previous_close)

local bullish_harami =
    previous_body > 0 and
    current_body > 0 and
    current_body_high <= previous_body_high and
    current_body_low >= previous_body_low and
    previous_bearish and
    current_bullish

local bearish_harami =
    previous_body > 0 and
    current_body > 0 and
    current_body_high <= previous_body_high and
    current_body_low >= previous_body_low and
    previous_bullish and
    current_bearish

local lower_shadow = current_body_low - low_now
local upper_shadow = high_now - current_body_high
local bullish_hammer =
    current_range > 0 and
    current_body > 0 and
    lower_shadow >= current_body * 2 and
    upper_shadow <= current_body

local first_midpoint = (first_open + first_close) / 2
local bullish_morning_star =
    first_close < first_open and
    first_body > 0 and
    previous_body <= first_body * 0.5 and
    current_bullish and
    close_now > first_midpoint

local bearish_evening_star =
    first_close > first_open and
    first_body > 0 and
    previous_body <= first_body * 0.5 and
    current_bearish and
    close_now < first_midpoint

local bullish_pattern =
    bullish_engulfing or
    bullish_harami or
    bullish_hammer or
    bullish_morning_star

local bearish_pattern =
    bearish_engulfing or
    bearish_harami or
    bearish_evening_star

-- Four independent directional families with source-engine weights.
local bullish_score = 0
local bearish_score = 0
local bullish_count = 0
local bearish_count = 0

if rsi_now >= 75 then
    bearish_score = bearish_score + 10
    bearish_count = bearish_count + 1
elseif rsi_now <= 25 then
    bullish_score = bullish_score + 10
    bullish_count = bullish_count + 1
elseif rsi_now > 70 then
    bearish_score = bearish_score + 8
    bearish_count = bearish_count + 1
elseif rsi_now < 30 then
    bullish_score = bullish_score + 8
    bullish_count = bullish_count + 1
elseif rsi_now > 60 then
    bearish_score = bearish_score + 4
    bearish_count = bearish_count + 1
elseif rsi_now < 40 then
    bullish_score = bullish_score + 4
    bullish_count = bullish_count + 1
end

if macd_histogram_atr_now > macd_moderate_atr then
    if macd_histogram_now > 0 then
        if macd_histogram_atr_now > macd_strong_atr then
            bullish_score = bullish_score + 9
        else
            bullish_score = bullish_score + 7
        end
        bullish_count = bullish_count + 1
    elseif macd_histogram_now < 0 then
        if macd_histogram_atr_now > macd_strong_atr then
            bearish_score = bearish_score + 9
        else
            bearish_score = bearish_score + 7
        end
        bearish_count = bearish_count + 1
    end
end

local bollinger_position = 0.5
if upper_now > lower_now then
    bollinger_position = (close_now - lower_now) / (upper_now - lower_now)
    if close_now >= upper_now then
        bearish_score = bearish_score + 7
        bearish_count = bearish_count + 1
    elseif close_now <= lower_now then
        bullish_score = bullish_score + 7
        bullish_count = bullish_count + 1
    elseif bollinger_position > 0.8 then
        bearish_score = bearish_score + 3
        bearish_count = bearish_count + 1
    elseif bollinger_position < 0.2 then
        bullish_score = bullish_score + 3
        bullish_count = bullish_count + 1
    end
end

if bullish_pattern and not bearish_pattern then
    bullish_score = bullish_score + 10
    bullish_count = bullish_count + 1
elseif bearish_pattern and not bullish_pattern then
    bearish_score = bearish_score + 10
    bearish_count = bearish_count + 1
end

local direction = 0
local winning_score = 0
local losing_score = 0
local winning_count = 0

if bullish_score > bearish_score and
    bullish_count >= minimum_agreeing_families then
    direction = 1
    winning_score = bullish_score
    losing_score = bearish_score
    winning_count = bullish_count
elseif bearish_score > bullish_score and
    bearish_count >= minimum_agreeing_families then
    direction = -1
    winning_score = bearish_score
    losing_score = bullish_score
    winning_count = bearish_count
end

-- Source confidence structure, corrected so ATR risk is applied only once.
local confluence_strength = 0
if direction ~= 0 then
    local directional_total = winning_score + losing_score
    local agreement = 0
    if directional_total > 0 then
        agreement = winning_score / directional_total
    end
    local strength = math.min (1.0, winning_score / 34.0)
    local coverage = math.min (1.0, winning_count / 4.0)
    confluence_strength = math.floor (
        agreement * 40.0 +
        strength * 35.0 +
        coverage * 25.0 +
        0.5
    )

    local atr_percent = atr_now / close_now * 100.0
    if atr_percent > high_atr_percent then
        confluence_strength = math.max (0, confluence_strength - 8)
    elseif atr_percent < low_atr_percent then
        confluence_strength = math.min (100, confluence_strength + 3)
    end
end

-- Direction-gated strategy recognition. A label boost can never reverse or
-- create a signal; only the unboosted confluence threshold controls advice.
local strategy_boost = 0

if direction == 1 then
    if rsi_now < 25 and (bullish_pattern or close_now <= lower_now) then
        strategy_boost = 15
    elseif rsi_now < 30 and bullish_pattern then
        strategy_boost = 12
    end

    if close_now > upper_now and
        macd_histogram_now > 0 and
        macd_histogram_atr_now > macd_moderate_atr then
        strategy_boost = math.max (strategy_boost, 12)
    end

    if macd_histogram_now > 0 and
        rsi_now >= 40 and
        rsi_now <= 70 and
        close_now > middle_now then
        strategy_boost = math.max (strategy_boost, 10)
    end

    if macd_histogram_now > 0 and
        macd_histogram_atr_now > macd_strong_atr and
        rsi_now >= 55 and
        rsi_now <= 70 and
        bullish_count >= 3 then
        strategy_boost = math.max (strategy_boost, 8)
    end
elseif direction == -1 then
    if rsi_now > 75 and (bearish_pattern or close_now >= upper_now) then
        strategy_boost = 15
    elseif rsi_now > 70 and bearish_pattern then
        strategy_boost = 12
    end

    if close_now < lower_now and
        macd_histogram_now < 0 and
        macd_histogram_atr_now > macd_moderate_atr then
        strategy_boost = math.max (strategy_boost, 12)
    end

    if macd_histogram_now < 0 and
        rsi_now >= 30 and
        rsi_now <= 60 and
        close_now < middle_now then
        strategy_boost = math.max (strategy_boost, 10)
    end

    if macd_histogram_now < 0 and
        macd_histogram_atr_now > macd_strong_atr and
        rsi_now >= 30 and
        rsi_now <= 45 and
        bearish_count >= 3 then
        strategy_boost = math.max (strategy_boost, 8)
    end
end

local display_strength = math.min (100, confluence_strength + strategy_boost)
local is_elite = strategy_boost > 0 and display_strength >= 80

signal_gun_call_setup = conditional (
    data_is_ready and
    direction == 1 and
    confluence_strength >= minimum_strength
)

signal_gun_put_setup = conditional (
    data_is_ready and
    direction == -1 and
    confluence_strength >= minimum_strength
)

signal_gun_elite_call_setup = conditional (
    data_is_ready and
    direction == 1 and
    confluence_strength >= minimum_strength and
    is_elite
)

signal_gun_elite_put_setup = conditional (
    data_is_ready and
    direction == -1 and
    confluence_strength >= minimum_strength and
    is_elite
)

confirmed_signal_gun_call = conditional (
    get_value (signal_gun_call_setup [1], false) and
    not get_value (signal_gun_call_setup [2], false)
)

confirmed_signal_gun_put = conditional (
    get_value (signal_gun_put_setup [1], false) and
    not get_value (signal_gun_put_setup [2], false)
)

-- Elite status is read from the same completed candle as the confirmed pulse.
confirmed_elite_call = conditional (
    get_value (confirmed_signal_gun_call, false) and
    get_value (signal_gun_elite_call_setup [1], false)
)

confirmed_elite_put = conditional (
    get_value (confirmed_signal_gun_put, false) and
    get_value (signal_gun_elite_put_setup [1], false)
)

confirmed_standard_call = conditional (
    get_value (confirmed_signal_gun_call, false) and
    not get_value (signal_gun_elite_call_setup [1], false)
)

confirmed_standard_put = conditional (
    get_value (confirmed_signal_gun_put, false) and
    not get_value (signal_gun_elite_put_setup [1], false)
)

if bands_visible then
    plot (bollinger_upper, "Upper Bollinger Band", upper_band_color, band_width)
    plot (bollinger_middle, "Bollinger Middle", middle_band_color, band_width)
    plot (bollinger_lower, "Lower Bollinger Band", lower_band_color, band_width)
end

if signals_visible then
    plot_shape (
        confirmed_standard_call,
        "Signal Gun CALL",
        shape_style.triangleup,
        shape_size.small,
        call_color,
        shape_location.belowbar,
        -1,
        "CALL",
        signal_text_color
    )

    plot_shape (
        confirmed_standard_put,
        "Signal Gun PUT",
        shape_style.triangledown,
        shape_size.small,
        put_color,
        shape_location.abovebar,
        -1,
        "PUT",
        signal_text_color
    )

    plot_shape (
        confirmed_elite_call,
        "Signal Gun aligned CALL",
        shape_style.triangleup,
        shape_size.large,
        elite_call_color,
        shape_location.belowbar,
        -1,
        "GUN+ CALL",
        signal_text_color
    )

    plot_shape (
        confirmed_elite_put,
        "Signal Gun aligned PUT",
        shape_style.triangledown,
        shape_size.large,
        elite_put_color,
        shape_location.abovebar,
        -1,
        "GUN+ PUT",
        signal_text_color
    )
end

-- QCS advice is a notification state only and never opens a position.
if advice_enabled and
    get_value (confirmed_signal_gun_call, false) and
    not get_value (confirmed_signal_gun_put, false) then
    advise (advice.buy)
elseif advice_enabled and
    get_value (confirmed_signal_gun_put, false) and
    not get_value (confirmed_signal_gun_call, false) then
    advise (advice.sell)
else
    advise (advice.neutral)
end