Quantum Class Reference

// Everything a strategy can reach, besides the standard JavaScript built-ins:
market     // everything you READ
broker     // everything you DO
log        // log("…"), log.warn, log.error, log.plot
params     // your resolved parameters
context    // all of it in one object (the same as this.c)
console    // console.log / .warn / .error route to the same log

class OpeningDrive extends Strategy {
  static get label() { return "Opening drive" }
  static get barSeconds() { return 300 }
  static get params() {
    return {
      minRangeTicks: { def: 40, lo: 4, hi: 400, group: "Entry",
        desc: "The first bar must be at least this wide." },
      stopTicks: { def: 30, lo: 4, hi: 400, group: "Stops", desc: "Fallback stop." },
    }
  }

  init() { this.tookTrade = false }            // once per instance (per day in a backtest)

  signal() {
    const bar = market.bar(0)
    if (bar.close === undefined || this.tookTrade) return 0
    if (bar.nyMin !== 935) return 0              // only the 9:35 bar (the first RTH 5-minute bar)
    if (market.toTicks(bar.high - bar.low) < params.minRangeTicks) return 0
    this.tookTrade = true
    return market.closeLocation(0) > 0.5 ? 1 : -1
  }

  suggestedStop(isLong) {                       // a PRICE, or NaN for params.stopTicks
    const bar = market.bar(0)
    return isLong ? bar.low - market.tickSize : bar.high + market.tickSize
  }
}

OpeningDrive

const bar = market.bar(0)                        // the bar that just closed
const fifteen = market.bar(0, 900)               // the last closed 15-minute bar
const minute = market.bar1m(0)                   // the last closed 1-minute bar
const where = market.closeLocation(0)            // 0 at the low .. 1 at the high
const atr = market.atr(14)                       // average true range, in price
const ticks = market.toTicks(bar.high - bar.low) // price distance in ticks
log("last " + market.price + " on bar " + market.barIndex)

market.timeframes            // every name this run can serve
market.bar(0, "15m")             // or market.bar15m(0)
market.footprint(0, "5m")        // or market.footprint5m(0)
market.ssl(0, "5m")              // chart, 1m and 5m only
market.structureAt("15m")        // the same object as market.structure15m
market.fairValueGaps("15m", { unfilledOnly: true })
market.indicators.rsi({ period: 14 }, 0, "15m")    // settings, barsAgo, timeframe

market.bar(0, "7m")
// Error: market.bar(): no timeframe "7m". It takes: chart, own, 1m, 2m, 3m,
// 5m, 10m, 15m, 30m, 1h, 2h, 4h, 1d -- or a number of seconds

const bar = market.bar(0)
if (bar.close === undefined) return 0            // not enough bars yet
if (bar.deltaFromBar) return 0                   // delta is MISSING here, not zero

// A bar that ran to -400 and closed at -380 was one-sided; one that ran to
// -400 and closed at -100 changed its mind. Same net delta, different trade.
const oneSidedSelling = bar.delta < 0 && bar.delta <= 0.8 * bar.deltaMin

// Time filters without date arithmetic
const isFirstHour = bar.nyMin >= 570 && bar.nyMin < 630   // 9:30–10:30 New York
const isFriday = bar.dow === 5

const ladder = market.footprint(0)
if (!ladder.cells) return 0                      // no ladder (e.g. a stored-bar backtest)

// One run of six or more buy imbalances -- not two runs of three
const deepBuyStack = ladder.stacks.some(run => run.isBuy && run.levels >= 6)

// Where the heaviest selling sat inside the bar
let heaviestBid = ladder.cells[0]
for (const cell of ladder.cells) if (cell.bid > heaviestBid.bid) heaviestBid = cell

// The chart's own signals, computed for you
if (ladder.unfinishedHigh || ladder.exhaustion) log("auction looks done at " + ladder.high)
const arrow = market.stackedImbalance(0, { minLevels: 3, closePercent: 0.8, priorBars: 2 })

const structure = market.structure
if (structure.dir === undefined) return 0        // not enough bars yet

// EVENTS fire on the bar that broke: test these, not a level
if (structure.bosNow === 1 && !structure.lastBreak.isChoch) {
  const lastBreak = structure.bos[structure.bos.length - 1]
  log("bullish BOS at " + lastBreak.price +
      (lastBreak.zoneTop ? ", order block " + lastBreak.zoneBot + "-" + lastBreak.zoneTop : ""))
}

// The range, with the chart's own names for it ("Strong Low", "Weak High" …)
log(structure.lowName + " " + structure.strongLow + " / " + structure.highName + " " + structure.strongHigh)

// Unbroken demand zones below price
const demand = structure.zones.filter(z => !z.isSupply && !z.broken && z.top < market.price)

// Higher timeframe, as of its last CLOSED bar -- compare bars with .bar, not barIndex
const htf = market.structure15m
const htfJustBroke = htf.bos && htf.bos.length && htf.bos[htf.bos.length - 1].endBar === htf.bar

// Unfilled gaps from the last 50 bars, newest first
const gaps = market.fairValueGaps({ unfilledOnly: true, maxAgeBars: 50, limit: 5 })
for (const gap of gaps) {
  if (gap.bullish && market.price <= gap.top && market.price >= gap.bot) {
    log("price is inside a bullish gap " + gap.bot + "-" + gap.top +
        " (" + gap.sizeTicks + " ticks, " + Math.round(gap.fillPct * 100) + "% filled)")
  }
}

// Only gaps made by a real impulse bar
const strong = market.fairValueGaps({ minBodyPct: 0.6, minVolMult: 1.5 })

// A misspelled option is refused by name, with the list of real ones
market.fairValueGaps({ unfiledOnly: true })
// Error: fairValueGaps(): has no option "unfiledOnly". It takes: bullish, unfilledOnly, …

const priorDay = market.priorDay(0)            // yesterday's completed RTH session
if (!priorDay.high) return 0                    // none yet (e.g. the first day of a run)

const today = market.today()                    // the session in progress
const aboveYesterday = market.price > priorDay.high
const insideIB = market.price > today.ibLow && market.price < today.ibHigh
const week = market.priorWeek(0)                // { open, high, low, close, range, from, to }

const profile = market.marketProfile(0)         // yesterday's TPO profile
const volume = market.valueArea(0)              // yesterday's VOLUME profile
if (!profile.vah || !volume.poc) return 0       // no completed session yet

// The 80% rule is written against the TPO value area, not the volume one
const openedBelowValue = market.today().open < profile.val
log("TPO " + profile.val + "-" + profile.vah + " POC " + profile.poc +
    " | volume POC " + volume.poc)

// The same two reads, one desk at a time: "asia", "london", "newyork" ("ny").
// n counts THAT desk's own sessions -- va(1, "asia") is the Asia before last,
// never yesterday's London.
const asiaLetters = market.marketProfile(0, "asia")   // where TIME was spent
const asiaVolume  = market.valueArea(0, "asia")       // where SIZE traded

// The desk volume cut is a second walk of the tick log, and asking is what
// starts it. Test for a level, never for emptiness: pending means "not yet",
// an empty map means "no such session", and a rule that cannot tell them
// apart will trade the warm-up.
if (asiaVolume.pending) return 0
if (!asiaVolume.poc || !asiaLetters.poc) return 0

// The pair disagreeing is the reading: a volume POC well away from the TPO POC
// says the night's size went somewhere the clock did not.
const apart = Math.abs(asiaVolume.poc - asiaLetters.poc)
log("Asia volume POC " + asiaVolume.poc + " vs letters " + asiaLetters.poc +
    " (" + market.toTicks(apart) + " ticks apart)")

// 0 is this strategy's own series; a number of SECONDS is another one.
const own = market.measuredMove(0)              // newest move on our own bars
const higher = market.measuredMove(0, 900)      // and the 15-minute one
if (!own.target) return 0                       // no move folded yet

// Only trade the open ones, with the trend, when the fib was a clean touch
const tradeable = own.open && own.trend === "with" && own.quality !== "ok"
log("MM " + (own.long ? "long" : "short") + " trigger " + own.trigger +
    " target " + own.target + " " + own.quality +
    " | " + market.measuredMoveCount(900) + " on 15m")

const mom = market.momentum(0)
if (!mom.trend) return 0                        // no momentum on this host

// The EVENT, confirmed by the ribbon: trade the flip, not the state
if (mom.signal > 0 && market.ssl(0).state > 0) return 1

// Or the ungated engine, for the Pine's timing
if (market.momentum(0, { raw: true }).signal < 0) return -1

// Still in the move it called?
const riding = mom.lastSignal > 0 && mom.barsSinceSignal < 20

const ribbon = market.ssl(0)                    // this chart's SSL channel
if (ribbon.line === undefined) return 0         // warming up: no answer, not neutral
if (ribbon.state > 0 && market.bar(0).close > ribbon.line) return 1

// The 5-minute channel as of the last 5-minute bar that had CLOSED -- cannot repaint
const fiveMinute = market.ssl5m(0)
const aligned = fiveMinute.state === ribbon.state

if (!market.book.available) return 0          // always false in a backtest

const book = market.book.stat("BOOK")           // { ratio, wbid, wask }
const imbalance = market.book.stat("IMB")       // { ratio, buy, sell, buySide }
const lastMinute = market.book.series("BOOK.ratio", 60)   // about one sample a second
if (book.ratio > 1.5 && imbalance.buySide) log("book leaning bid, tape lifting")

onBar() {
  const position = broker.position              // { qty, avg, long, short, flat }
  if (position.long && market.bar(0).close < this.exitLevel) {
    broker.flatten()                            // close at market, drop the bracket
  }
  super.onBar()                                 // keep consulting signal() while flat
}

// Placing an order yourself -- ALWAYS with a stop
const placed = broker.buy({ qty: 1, stopTicks: 20, targetTicks: 40 })
if (!placed) log.warn("entry refused")

log("entry: close " + market.bar(0).close + " above " + this.level)
log.warn("skipped: spread too wide")
log.error("unexpected state")
log.plot("closeLocation", market.closeLocation(0))   // up to 8 named series
console.log("same as log()")