Bitcoin Elite Breakdown Filter

// === Setup ===
describe_indicator('BTC Break-Down Probability', 'lower', { shortName: 'BTC_break_down' });

// === Helpers ===
function isoToUnix(iso) {
  const m = iso.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?(Z|[+\-]\d{2}:\d{2})$/);
  if (!m) return null;
  const [, Y, M, D, h, mi, s='0', tz] = m;
  const utcMs = Date.UTC(+Y, +M-1, +D, +h, +mi, +s);
  if (tz === 'Z') return Math.floor(utcMs/1000);
  const sign = tz[0] === '+' ? 1 : -1;
  const offH = +tz.slice(1,3), offM = +tz.slice(4,6);
  return Math.floor((utcMs - sign*((offH*60+offM)*60*1000))/1000);
}
const toStart = (u, sec) => Math.floor(u/sec)*sec;
function detectResolutionSec(){ return time.length<2 ? 60 : (time[1]-time[0]); }

// === Settings (UI) ===
const API_KEY = 'YOUR_API_KEY_HERE';
const LIMIT   = 10000;

const SHOW_H1  = Number(input('Show h1 (0/1)', 1, [0,1])) === 1;
const SHOW_H2  = Number(input('Show h2 (0/1)', 1, [0,1])) === 1;
const SHOW_H4  = Number(input('Show h4 (0/1)', 1, [0,1])) === 1;
const SHOW_H8  = Number(input('Show h8 (0/1)', 1, [0,1])) === 1;

const TH_SHORT_1 = Number(input('SHORT h1 (0..1)', 0.60, { min:0, max:1, step:0.01 }));
const TH_SHORT_2 = Number(input('SHORT h2 (0..1)', 0.60, { min:0, max:1, step:0.01 }));
const TH_SHORT_4 = Number(input('SHORT h4 (0..1)', 0.60, { min:0, max:1, step:0.01 }));
const TH_SHORT_8 = Number(input('SHORT h8 (0..1)', 0.60, { min:0, max:1, step:0.01 }));

const TH_EXIT_1  = Number(input('EXIT h1 (0..1)',  0.10, { min:0, max:1, step:0.01 }));
const TH_EXIT_2  = Number(input('EXIT h2 (0..1)',  0.10, { min:0, max:1, step:0.01 }));
const TH_EXIT_4  = Number(input('EXIT h4 (0..1)',  0.10, { min:0, max:1, step:0.01 }));
const TH_EXIT_8  = Number(input('EXIT h8 (0..1)',  0.10, { min:0, max:1, step:0.01 }));

const PALETTE = ['aqua','#00e676','orange','violet','#2196f3','#ff9800','#9c27b0','#26a69a'];
const COL_1_IDX = Number(input('Color h1 preset', 4, { min:0, max:PALETTE.length-1, step:1 }));
const COL_2_IDX = Number(input('Color h2 preset', 6, { min:0, max:PALETTE.length-1, step:1 }));
const COL_4_IDX = Number(input('Color h4 preset', 2, { min:0, max:PALETTE.length-1, step:1 }));
const COL_8_IDX = Number(input('Color h8 preset', 3, { min:0, max:PALETTE.length-1, step:1 }));
const COLOR = { 1: PALETTE[COL_1_IDX], 2: PALETTE[COL_2_IDX], 4: PALETTE[COL_4_IDX], 8: PALETTE[COL_8_IDX] };

const SHADE_ZONES = Number(input('Shade zones (0/1)', 1, [0,1])) === 1;

// === Fetch ===
const headers = { 'Authorization': `Bearer ${API_KEY}` };
function endpointFor(h){
  const map = {
    1: 'btc-break-1h-down-h1',
    2: 'btc-break-1h-down-h2',
    4: 'btc-break-1h-down-h4',
    8: 'btc-break-1h-down-h8',
  };
  return map[h];
}
async function fetchRows(h){
  const url = `https://ts.marbell.com/${endpointFor(h)}?limit=${LIMIT}&expand=false`;
  const resp = await request.http(url, 300, headers);
  assert(!resp.error, `Error fetching BTC break-down (h=${h}): ${resp.error}`);
  assert(Array.isArray(resp), `Unexpected response format for h=${h}`);
  return resp;
}

// === Indexing ===
const resSec = detectResolutionSec();
const idxByUnix = {}; for (let i=0;i<time.length;i++) idxByUnix[time[i]] = i;

// === Containers per horizon ===
function makeSeries(){ return Array(close.length).fill(null); }
const prob   = { 1: makeSeries(), 2: makeSeries(), 4: makeSeries(), 8: makeSeries() };
const aboveS = { 1: makeSeries(), 2: makeSeries(), 4: makeSeries(), 8: makeSeries() };
const belowX = { 1: makeSeries(), 2: makeSeries(), 4: makeSeries(), 8: makeSeries() };

const TH_SHORT = { 1:TH_SHORT_1, 2:TH_SHORT_2, 4:TH_SHORT_4, 8:TH_SHORT_8 };
const TH_EXIT  = { 1:TH_EXIT_1,  2:TH_EXIT_2,  4:TH_EXIT_4,  8:TH_EXIT_8  };

// === TF helpers ===
const isLowerTF  = (intervalSec) => resSec < intervalSec;
const isEqualTF  = (intervalSec) => resSec === intervalSec;
const isHigherTF = (intervalSec) => resSec > intervalSec;

// === Load & map ===
const TO_SHOW = [
  ...(SHOW_H1 ? [1] : []),
  ...(SHOW_H2 ? [2] : []),
  ...(SHOW_H4 ? [4] : []),
  ...(SHOW_H8 ? [8] : []),
];

for (const H of TO_SHOW) {
  const rows = await fetchRows(H);
  for (const r of rows) {
    const u = isoToUnix(r.timestamp);
    if (u == null) continue;

    const intervalSec = 3600;
    const uStart = toStart(u, intervalSec);
    const p = Number(r.probability);
    if (!isFinite(p)) continue;

    const writeAt = (idx) => {
      if (idx === undefined) return;
      prob[H][idx] = p;
      if (SHADE_ZONES){
        if (p >= TH_SHORT[H])      { aboveS[H][idx] = p; belowX[H][idx] = null; }
        else if (p <= TH_EXIT[H])  { belowX[H][idx] = p; aboveS[H][idx] = null; }
        else { aboveS[H][idx] = null; belowX[H][idx] = null; }
      }
    };

    if (isLowerTF(intervalSec)) {
      const pointsPerInterval = Math.max(1, Math.floor(intervalSec / resSec));
      for (let k=0;k<pointsPerInterval;k++){
        writeAt(idxByUnix[uStart + k*resSec]);
      }
    } else if (isEqualTF(intervalSec)) {
      writeAt(idxByUnix[uStart]);
    } else {
      if (uStart % resSec === 0) writeAt(idxByUnix[uStart]);
    }
  }
}

// === Static guides ===
const h0 = Array(close.length).fill(0);
const h1 = Array(close.length).fill(1);
plot(h0, '0', '#808080');
plot(h1, '1', '#808080');

function label(th, H, kind){ return `${kind} h${H} ${kind==='SHORT'?'≥':'≤'} ${Math.round(th*100)}%`; }

for (const H of TO_SHOW) {
  plot(prob[H], `P↓ (h${H})`, COLOR[H]);

  const hShort = Array(close.length).fill(TH_SHORT[H]);
  const hExit  = Array(close.length).fill(TH_EXIT[H]);
  plot(hShort, label(TH_SHORT[H], H, 'SHORT'), '#ff0000');
  plot(hExit,  label(TH_EXIT[H],  H, 'EXIT'),  '#00ff00');

  if (SHADE_ZONES){
    plot(aboveS[H], `Zone SHORT h${H}`, '#ff0000');
    plot(belowX[H], `Zone EXIT h${H}`,  '#00ff00');
  }
}