Market HUD

// Market HUD: one card in a corner of the price pane that reads the market in one glance, drawn by the chart in the
// glass look. The trader sees the trend word first, large (Bullish when the close is above the EMA and RSI is above
// its midline, Bearish when it is below both, else Mixed, in the bull, bear or neutral colour), then three activity
// rings with their readings beside them (RSI, the taker buy share over the flow window, and this bar's volume so far
// against its average over the same window), then ATR as a percent of price and the open-interest change over the
// flow window as a filled line, counted in contracts: coins on a perpetual (the dollar reading over the bar's close, so
// a price move alone never moves it), the reading as served on a prediction market (already a count of YES and NO
// pairs). The EMA itself is drawn on price. A tile whose market has no data prints a dash:
// open interest on spot, stocks and FX; the taker share where the venue has no sided trades. Every number on the card
// is a data-only output written on every bar, so the line has history and the Console or a watch reads the same
// values the card shows (the close's distance from the EMA too).

// Settings: every length is a whole number with bounds; the flow window also spans the open-interest change. The
// trend word's RSI midline is a setting too, and the last section holds the EMA line's colour.
section("Lengths");
param.int("ema_len", 50, { min: 2, max: 400, label: "EMA length, bars", description: "EMA length in bars, the trend reference" });
param.int("rsi_len", 14, { min: 2, max: 200, label: "RSI length, bars", description: "RSI length in bars (Wilder smoothing)" });
param.int("atr_len", 14, { min: 2, max: 200, label: "ATR length, bars", description: "ATR length in bars (Wilder smoothing)" });
param.int("flow_len", 20, { min: 2, max: 200, label: "Flow window, bars", description: "Bars in the flow window and in the open-interest change" });
section("Trend word");
param.number("rsi_mid", 50, { min: 1, max: 99, step: 1, label: "RSI midline", description: "RSI midline: Bullish needs RSI above it and the close above the EMA, Bearish needs both below" });
section("Look");
param.color("ema_color", "#38bdf8", { label: "EMA line" });

// The legend reads the lengths after the name ("Market HUD 50 14 14 20"): a tile label is a fixed string, so the
// card's labels name what they read in words and the settings in use ride the legend.
legend({ title: "{{ema_len}} {{rsi_len}} {{atr_len}} {{flow_len}}" });

// Inputs: the chart's own candles set the grid; flow reads sided trades (a bar with no prints reads 0); open
// interest reads NaN on a bar without a reading and where the market has none; funding is served on perpetuals only
// (NaN elsewhere), which tells the file its open interest is dollars to turn into coins.
input("close", ohlcv.close);
input("buy", trades.volume, { side: "BUY", missing: "zero" });
input("sell", trades.volume, { side: "SELL", missing: "zero" });
input("oi", oi.close, { missing: "nan" });
input("funding", funding.rate_close, { missing: "nan" });

// Outputs: the EMA is drawn on price; the rest are data-only, one value per bar behind the card's tiles. The first
// five keep their names and order from the earlier card; the trend rung, the EMA distance and the buy share are new.
// A static colour on a data-only output is the colour its dial, sparkline or meter draws in.
const emaLine = output("ema", line, overlay, { color: "@ema_color", width: 1, label: "EMA", format: "price", description: "EMA of the close over ema_len bars" }); // the colour setting paints it; the handle names it for the hover card
output("rsi", none, overlay, { color: "#a78bfa", format: "0.0", description: "RSI of the close over rsi_len bars" });
output("atr_pct", none, overlay, { format: "%", description: "ATR over atr_len bars as a percent of the close" });
output("flow", none, overlay, { description: "Buy minus sell volume over flow_len bars, as a percent of their sum" });
output("oi_change", none, overlay, { color: "#2dd4bf", format: "%", description: "Open-interest change over flow_len bars in contracts (coins on a perpetual, as served on a prediction market), percent" });
output("trend", none, overlay, { description: "The trend word as a ladder rung: 0 bearish, 1 mixed, 2 bullish" });
output("ema_dist", none, overlay, { format: "%", description: "Close minus the EMA, as a percent of the EMA" });
output("buy_share", none, overlay, { color: "#94a3b8", format: "%", description: "Taker buy volume over flow_len bars, as a percent of all taker volume" });
output("volume_ratio", none, overlay, { format: "%", description: "Bar volume as a percent of its average over flow_len bars; on the live bar, its volume so far" });
hover(emaLine, [block.value("EMA", "ema", { format: "price" }), block.rows([["RSI", "rsi", "0.0"], ["ATR %", "atr_pct", "0.00"], ["Flow %", "flow", "0.0"], ["OI change in contracts %", "oi_change", "0.00"]])]); // the card the EMA line opens under the cursor: its value and the card's numbers

// The trend word (or the bars the card still needs), written on the live bar into a bounded string slot the first
// tile reads.
string("trend_word", { max_bytes: 16 });

// The card, in the glass look (rounded type, a large headline, rings): the trend word leads as the headline across
// both columns, its colour following the trend rung (bear, neutral, bull); the rings span the card under it, RSI on
// the outer ring; ATR and the open-interest line pair up below. The look word takes any shipped look name.
render.hud("market", { position: "bottom_center", look: "glass", title: "Market", columns: 2, tiles: [
  tile.pill("Trend", "trend_word", { headline: true, color_by: "trend", colors: ["#ff003c", "#94a3b8", "#10b981"] }),
  tile.rings("Momentum, flow and volume", [
    ["RSI", "rsi", { min: 0, max: 100, color: "#fa114f" }],
    ["Buy share", "buy_share", { min: 0, max: 100, color: "#a6ff00" }],
    ["Volume so far", "volume_ratio", { min: 0, max: 200, color: "#00f0ff" }],
  ]),
  tile.value("ATR, % of price", "atr_pct", { format: "%" }),
  tile.spark("OI in contracts", "oi_change", { bars: 64 }),
] });

// The flow window is a ring of the last bars' buy and sell volume, sized for the largest window at load; onStart()
// reads the window in use.
const MAX_WINDOW = 200;
const buys = new StaticArray<f64>(MAX_WINDOW);
const sells = new StaticArray<f64>(MAX_WINDOW);
const vols = new StaticArray<f64>(MAX_WINDOW);
let volBars = 0;

let flowLen = 20;
let rsiMid = 50.0;
let warmBars = 50; // the bars the EMA, RSI and ATR need before the card answers
let ema = new Ema(50);
let rsi = new Rsi(14);
let atr = new Atr(14);
let rawChange = new Roc(20); // the open-interest change as served, and in coins: the funding feed picks one
let coinChange = new Roc(20);
let oiRaw: f64 = NaN; // the last open-interest reading and its coins; a new bar keeps them until its own reading lands
let oiCoins: f64 = NaN;
let perp = false; // funding seen: a perpetual, whose dollar open interest moves with price
let head = 0;

// onStart() runs once before the first bar: read the settings and size the helpers to them.
function onStart(): void {
  flowLen = i32(p_flow_len());
  rsiMid = p_rsi_mid();
  warmBars = i32(Math.max(p_ema_len(), Math.max(p_rsi_len() + 1.0, p_atr_len())));
  ema = new Ema(i32(p_ema_len()));
  rsi = new Rsi(i32(p_rsi_len()));
  atr = new Atr(i32(p_atr_len()));
  rawChange = new Roc(flowLen);
  coinChange = new Roc(flowLen);
}

// onBar() runs once per bar: fold the bar into every helper and the flow ring, then write the outputs; the trend
// word is written on the live bar only.
function onBar(): void {
  const close = bar.close();
  const emaValue = ema.update(close);
  const rsiValue = rsi.update(close);
  const atrPct = (atr.update(bar.high(), bar.low(), close) / close) * 100.0;

  // The ring's sums are recounted from its slots: a running sum that adds and subtracts keeps a rounding crumb
  // after a quiet stretch, and a crumb over a crumb would read as a share.
  buys[head] = in_buy();
  sells[head] = in_sell();
  vols[head] = bar.volume();
  head = (head + 1) % flowLen;
  if (volBars < flowLen) volBars += 1;
  let buySum = 0.0;
  let sellSum = 0.0;
  let volSum = 0.0;
  for (let i = 0; i < flowLen; i += 1) {
    buySum += buys[i];
    sellSum += sells[i];
    volSum += vols[i];
  }
  const total = buySum + sellSum;
  const flowPct = total > 0.0 ? ((buySum - sellSum) / total) * 100.0 : NaN; // NaN where the venue has no sided trades
  const buyShare = total > 0.0 ? (buySum / total) * 100.0 : NaN;
  const oiNow = in_oi();
  if (!isNaN(oiNow)) {
    oiRaw = oiNow;
    oiCoins = oiNow / close; // dollars over the close: the coins, whatever price did
  }
  if (!isNaN(in_funding())) perp = true;
  const rawPct = rawChange.update(oiRaw);
  const coinPct = coinChange.update(oiCoins);
  const oiPct = perp ? coinPct : rawPct; // NaN on markets without open interest, and until the window is full
  const volAvg = volSum / f64(volBars);

  if (isNaN(emaValue) || isNaN(rsiValue) || isNaN(atrPct)) { // warm-up rows write nothing; the live bar says why
    if (bar.isLast()) { sb_clear(); sb_text("Needs "); sb_int(warmBars); sb_text(" bars"); str_trend_word_sb(); }
    return;
  }
  const bullish = close > emaValue && rsiValue > rsiMid;
  const bearish = close < emaValue && rsiValue < rsiMid;
  out_ema(emaValue);
  out_rsi(rsiValue);
  out_atr_pct(atrPct);
  out_flow(flowPct);
  out_oi_change(oiPct);
  out_trend(bearish ? 0.0 : bullish ? 2.0 : 1.0);
  out_ema_dist(((close - emaValue) / emaValue) * 100.0);
  out_buy_share(buyShare);
  out_volume_ratio(volAvg > 0.0 ? (bar.volume() / volAvg) * 100.0 : NaN); // on the live bar, its volume so far
  if (bar.isLast()) {
    sb_clear();
    sb_text(bullish ? "Bullish" : bearish ? "Bearish" : "Mixed");
    str_trend_word_sb();
  }
}