Backtesting Big Trades

// Fades big trades that sweep thin liquidity.
// https://marketbyorder.com/docs/api/algos

interface SymbolParams {
  minSize: number
  thinThreshold: number
}
const SYMBOL_PARAMS: Record<string, SymbolParams> = {
  ES: { minSize: 120, thinThreshold: 45 },
  CL: { minSize: 50, thinThreshold: 15 },
}
const DEFAULT_PARAMS = SYMBOL_PARAMS.ES

function paramsFor(sym: string): SymbolParams {
  const key = Object.keys(SYMBOL_PARAMS).find(k => sym.toUpperCase().startsWith(k))
  if (!key) {
    print(`Thin Liquidity Fade: no tuned params for symbol "${sym}", falling back to ES defaults`)
    return DEFAULT_PARAMS
  }
  return SYMBOL_PARAMS[key]
}

const { minSize: MIN_SIZE, thinThreshold: THIN_THRESHOLD } = paramsFor(symbol)
const QTY = 1
const HOLD_MS = 5 * 60_000
const SL_TICKS = 7

const RTH_START = 9 * 60 + 30 // minutes after midnight, New York time
const RTH_END = 16 * 60 // minutes after midnight, New York time
const FLATTEN_BUFFER_MIN = 5

const exchangeTime = new Intl.DateTimeFormat('en-US', {
  timeZone: 'America/New_York',
  hourCycle: 'h23',
  weekday: 'short',
  hour: 'numeric',
  minute: 'numeric',
})

const sessionByMinute = new Map<number, { clock: number; weekday: string }>()
const sessionInfo = (ms: number) => {
  const minute = Math.floor(ms / 60000)
  const cached = sessionByMinute.get(minute)
  if (cached) return cached
  const parts = exchangeTime.formatToParts(ms)
  const get = (type: string) => parts.find((part) => part.type === type)?.value ?? ''
  const info = { clock: Number(get('hour')) * 60 + Number(get('minute')), weekday: get('weekday') }
  sessionByMinute.set(minute, info)
  return info
}

const isRth = (ms: number) => {
  const { clock, weekday } = sessionInfo(ms)
  return weekday !== 'Sat' && weekday !== 'Sun' && clock >= RTH_START && clock < RTH_END
}

const canEnter = (ms: number) => {
  const { clock, weekday } = sessionInfo(ms)
  return weekday !== 'Sat' && weekday !== 'Sun' && clock >= RTH_START && clock < RTH_END - FLATTEN_BUFFER_MIN
}

let exitTime: number | null = null

onUpdate(({ time, bid, ask, trades }) => {
  const pos = orders.position()

  if (pos.side !== "flat" && !canEnter(time)) {
    orders.flatten()
    exitTime = null
    return
  }
  if (orders.working().length > 0 && !canEnter(time)) {
    orders.cancelAll()
  }

  if (pos.side !== "flat" && exitTime !== null && time >= exitTime) {
    orders.flatten()
    exitTime = null
    return
  }

  if (pos.side !== "flat" || orders.working().length > 0 || !canEnter(time)) return

  for (const trade of trades) {
    if (trade.side === "none" || trade.size < MIN_SIZE) continue
    const levels = trade.levels.length
    const cpl = trade.size / levels
    if (cpl > THIN_THRESHOLD) continue

    if (trade.side === "buy") {
      const sl = bid + SL_TICKS * tickSize
      orders.sell(QTY, { sl })
      print(`FADE SELL: big BUY ${trade.size} swept ${levels} levels (cpl=${cpl.toFixed(1)}) - thin liquidity, sl=${sl.toFixed(2)}`)
    } else {
      const sl = ask - SL_TICKS * tickSize
      orders.buy(QTY, { sl })
      print(`FADE BUY: big SELL ${trade.size} swept ${levels} levels (cpl=${cpl.toFixed(1)}) - thin liquidity, sl=${sl.toFixed(2)}`)
    }
    exitTime = time + HOLD_MS
    break
  }
})