Quantum Strategy API

// @group trend
// EMA crossover -- go with the fast average crossing the slow one.
//
// THE RULE
//   When the fast EMA crosses above the slow EMA on a closed bar, go long.
//   When it crosses below, go short. The stop sits beyond the recent swing
//   and the target is a multiple of that risk. Built for NQ on 5-minute bars.
//
// WHY THE CROSS, NOT THE STATE
//   "fast > slow" is true on every bar of a trend. The cross -- the sign of
//   (fast - slow) changing -- is the event, so that is what is tested.
//
// WHAT IS KNOWN
//   A documentation sample. Untested; record results here as they come in.
//
// Research tool, not advice. Test it on Sim or Playback.

class EmaCrossover extends Strategy {

  /** @returns {string} what the library and the logs call it */
  static get label() { return "EMA crossover" }

  /** @returns {number} the bar this rule is written for, in seconds */
  static get barSeconds() { return 300 }

  /** @returns {Object} parameter declarations; these become the settings panel */
  static get params() {
    return {
      fastPeriod:  { def: 9, lo: 2, hi: 100, group: "Entry",
        desc: "The fast average. Shorter reacts sooner and whipsaws more." },
      slowPeriod:  { def: 21, lo: 3, hi: 400, group: "Entry",
        desc: "The slow average the fast one has to cross." },
      tradeShorts: { def: 1, lo: 0, hi: 1, group: "Entry",
        desc: "0 takes longs only." },
      swingBars:   { def: 5, lo: 1, hi: 50, group: "Stops",
        desc: "How many closed bars back to look for the swing the stop sits beyond." },
      stopTicks:   { def: 40, lo: 4, hi: 400, group: "Stops",
        desc: "Fallback stop when there are not enough bars to find a swing." },
      riskReward:  { def: 2.0, lo: 0.5, hi: 10, real: true, group: "Targets",
        desc: "Target as a multiple of the distance to the stop." },
      qty:         { def: 1, lo: 1, hi: 20, group: "Size", desc: "Contracts per entry." },
    }
  }

  /** Once per day, before the walk: forget yesterday's averages. */
  init() {
    this.previousSpread = undefined
    this.crossDirection = 0
  }

  /**
   * Every closed bar, flat or not. The cross is found here rather than in
   * signal(), because signal() is skipped while a position is open and would
   * miss every bar held in a trade.
   */
  onBar() {
    const fast = market.indicators.ema({ period: params.fastPeriod }).ema
    const slow = market.indicators.ema({ period: params.slowPeriod }).ema
    this.crossDirection = 0
    if (fast !== undefined && slow !== undefined) {   // undefined while warming up
      const spread = fast - slow
      if (this.previousSpread !== undefined) {
        if (this.previousSpread <= 0 && spread > 0) this.crossDirection = 1
        if (this.previousSpread >= 0 && spread < 0) this.crossDirection = -1
      }
      this.previousSpread = spread
    }
    super.onBar()   // still consult signal() while flat
  }

  /** Consulted only while flat: act on a cross that happened on this bar. */
  signal() {
    if (this.crossDirection === 1) {
      log("EMA " + params.fastPeriod + " crossed above " + params.slowPeriod + " at " + market.price)
      return 1
    }
    if (this.crossDirection === -1 && params.tradeShorts) {
      log("EMA " + params.fastPeriod + " crossed below " + params.slowPeriod + " at " + market.price)
      return -1
    }
    return 0
  }

  /**
   * The stop, as a PRICE: one tick beyond the lowest low (long) or highest
   * high (short) of the last few closed bars.
   * @param {boolean} isLong
   * @returns {number}
   */
  suggestedStop(isLong) {
    let swingLow = Infinity, swingHigh = -Infinity
    for (let barsAgo = 0; barsAgo < params.swingBars; ++barsAgo) {
      const closedBar = market.bar(barsAgo)
      if (closedBar.close === undefined) return NaN    // not enough bars: use stopTicks
      swingLow = Math.min(swingLow, closedBar.low)
      swingHigh = Math.max(swingHigh, closedBar.high)
    }
    return isLong ? swingLow - market.tickSize : swingHigh + market.tickSize
  }

  /**
   * Target in ticks: the stop distance times riskReward.
   * @param {boolean} isLong
   * @returns {number}
   */
  targetTicks(isLong) {
    const stopPrice = this.suggestedStop(isLong)
    const riskTicks = isNaN(stopPrice)
      ? params.stopTicks
      : market.toTicks(Math.abs(market.price - stopPrice))
    return Math.max(1, Math.round(riskTicks * params.riskReward))
  }
}

EmaCrossover

// @group structure
// BOS retest -- after a break of structure, buy the pullback to the level.
//
// THE RULE
//   When a bullish break of structure fires, remember the level it broke.
//   If price pulls back to that level within a few bars and the bar closes
//   back above it, go long, stop under that bar. Mirror for bearish breaks.
//   Built for NQ on 5-minute bars.
//
// WHY THE EVENT, NOT THE LEVEL
//   market.structure.bosNow fires on the bar that broke. A structure level is
//   present on the bar that made it and a hundred bars later, so the event is
//   what starts the wait, and the retest is what triggers the entry.
//
// WHAT IS KNOWN
//   A documentation sample. Untested; record results here as they come in.
//
// Research tool, not advice. Test it on Sim or Playback.

class BosRetest extends Strategy {

  /** @returns {string} */
  static get label() { return "BOS retest" }

  /** @returns {number} */
  static get barSeconds() { return 300 }

  /** @returns {Object} */
  static get params() {
    return {
      retestBars:     { def: 12, lo: 1, hi: 100, group: "Entry",
        desc: "How many bars after the break a retest still counts." },
      toleranceTicks: { def: 4, lo: 0, hi: 40, group: "Entry",
        desc: "How close to the broken level the pullback must come." },
      tradeShorts:    { def: 1, lo: 0, hi: 1, group: "Entry", desc: "0 takes longs only." },
      stopTicks:      { def: 40, lo: 4, hi: 400, group: "Stops",
        desc: "Fallback stop when the retest bar gives no usable level." },
      riskReward:     { def: 2.0, lo: 0.5, hi: 10, real: true, group: "Targets",
        desc: "Target as a multiple of the distance to the stop." },
      qty:            { def: 1, lo: 1, hi: 20, group: "Size", desc: "Contracts per entry." },
    }
  }

  /** Once per day: no break is waiting for a retest yet. */
  init() {
    this.pendingBreak = null
  }

  /**
   * Every closed bar: start waiting when a break fires, and stop waiting when
   * the retest window runs out. Done here so a break that fires while a
   * position is open is not missed.
   */
  onBar() {
    const structure = market.structure
    if (structure.bosNow === 1 || structure.bosNow === -1) {
      const lastBreak = structure.lastBreak
      if (lastBreak && lastBreak.price !== undefined && !lastBreak.isChoch) {
        this.pendingBreak = {
          isLong: structure.bosNow === 1,
          level: lastBreak.price,
          barIndex: market.barIndex,
        }
        log((this.pendingBreak.isLong ? "bullish" : "bearish") + " BOS at " + lastBreak.price + ", waiting for a retest")
      }
    }
    if (this.pendingBreak && market.barIndex - this.pendingBreak.barIndex > params.retestBars) {
      log("no retest of " + this.pendingBreak.level + " within " + params.retestBars + " bars")
      this.pendingBreak = null
    }
    super.onBar()
  }

  /** Consulted only while flat: enter on a bar that retests and holds the level. */
  signal() {
    const pending = this.pendingBreak
    if (!pending || market.barIndex === pending.barIndex) return 0   // not on the breaking bar itself
    const closedBar = market.bar(0)
    if (closedBar.close === undefined) return 0
    const tolerance = params.toleranceTicks * market.tickSize

    if (pending.isLong && closedBar.low <= pending.level + tolerance && closedBar.close > pending.level) {
      log("retest held above " + pending.level)
      this.pendingBreak = null
      return 1
    }
    if (!pending.isLong && params.tradeShorts
        && closedBar.high >= pending.level - tolerance && closedBar.close < pending.level) {
      log("retest held below " + pending.level)
      this.pendingBreak = null
      return -1
    }
    return 0
  }

  /**
   * The stop, as a PRICE: one tick beyond the retest bar.
   * @param {boolean} isLong
   * @returns {number}
   */
  suggestedStop(isLong) {
    const closedBar = market.bar(0)
    if (closedBar.close === undefined) return NaN
    return isLong ? closedBar.low - market.tickSize : closedBar.high + market.tickSize
  }

  /**
   * Target in ticks: the stop distance times riskReward.
   * @param {boolean} isLong
   * @returns {number}
   */
  targetTicks(isLong) {
    const stopPrice = this.suggestedStop(isLong)
    const riskTicks = isNaN(stopPrice)
      ? params.stopTicks
      : market.toTicks(Math.abs(market.price - stopPrice))
    return Math.max(1, Math.round(riskTicks * params.riskReward))
  }
}

BosRetest