Backtesting.

// Module 12, A Minimal Event-Driven Backtester
// Data: GET /markets/{slug}/oracle-candles (public, Chainlink OHLCV)
// Fill: next bar's open + configurable slippage. No look-ahead.

const BASE = 'https://api.limitless.exchange';
const FEE_BPS  = 20;                  // from /profiles/{account}.rank.feeRateBps
const SLIP_BPS = 15;                  // calibrated from /portfolio/trades

type Row = { timestamp: number; open: number; high: number; low: number; close: number; volume: number; };
type Signal = 0 | 1 | -1;
interface Strategy { onTick(row: Row, position: number): Signal; }

class MeanRevert implements Strategy {
  private history: number[] = [];
  onTick(row: Row, position: number): Signal {
    this.history.push(row.close);
    if (this.history.length < 20) return 0;
    const mean = this.history.slice(-20).reduce((a, b) => a + b) / 20;
    if (row.close < mean * 0.97 && position <= 0) return  1;
    if (row.close > mean * 1.03 && position >= 0) return -1;
    return 0;
  }
}

async function fetchCandles(slug: string, from: number, to: number): Promise<Row[]> {
  const url = `${BASE}/markets/${slug}/oracle-candles`
            + `?interval=1h&from=${from}&to=${to}`;
  const res = await fetch(url);
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return (await res.json()).rows as Row[];
}

async function backtest(slug: string, strategy: Strategy) {
  const now  = Math.floor(Date.now() / 1000);
  const from = now - 30 * 24 * 60 * 60;
  const rows = await fetchCandles(slug, from, now);

  const cost = (px: number, side: 1 | -1) =>
    px * (1 + side * (FEE_BPS + SLIP_BPS) / 10_000);

  let cash = 0, position = 0, entry = 0;
  for (let i = 0; i < rows.length - 1; i++) {
    const signal = strategy.onTick(rows[i], position);
    const nextOpen = rows[i + 1].open;       // fill at next bar's open
    if (signal === 1 && position === 0) {
      entry = cost(nextOpen, 1);  position = 1;
    } else if (signal === -1 && position === 1) {
      cash += cost(nextOpen, -1) - entry;  position = 0;
    }
  }
  console.log('Bars:', rows.length, 'Realised PnL:', cash.toFixed(4));
}

backtest('btc-above-100k-june', new MeanRevert()).catch(console.error);

# Module 12, A Minimal Event-Driven Backtester
# Data: GET /markets/{slug}/oracle-candles (public, Chainlink OHLCV)
# Fill: next bar's open + configurable slippage. No look-ahead.

import asyncio
import time
import httpx

BASE     = "https://api.limitless.exchange"
FEE_BPS  = 20    # from /profiles/{account}.rank.feeRateBps
SLIP_BPS = 15    # calibrated from /portfolio/trades


class MeanRevert:
    def __init__(self) -> None:
        self.history: list[float] = []

    def on_tick(self, row: dict, position: int) -> int:
        self.history.append(row["close"])
        if len(self.history) < 20:
            return 0
        mean = sum(self.history[-20:]) / 20
        if row["close"] < mean * 0.97 and position <= 0:
            return  1
        if row["close"] > mean * 1.03 and position >= 0:
            return -1
        return 0


async def fetch_candles(slug: str, frm: int, to: int) -> list[dict]:
    params = {"interval": "1h", "from": frm, "to": to}
    async with httpx.AsyncClient(timeout=10.0) as client:
        resp = await client.get(f"{BASE}/markets/{slug}/oracle-candles", params=params)
        resp.raise_for_status()
        return resp.json()["rows"]


async def backtest(slug: str, strategy) -> None:
    now  = int(time.time())
    rows = await fetch_candles(slug, now - 30 * 86_400, now)

    def cost(px: float, side: int) -> float:
        return px * (1 + side * (FEE_BPS + SLIP_BPS) / 10_000)

    cash, position, entry = 0.0, 0, 0.0
    for i in range(len(rows) - 1):
        signal = strategy.on_tick(rows[i], position)
        next_open = rows[i + 1]["open"]     # fill at next bar's open
        if signal == 1 and position == 0:
            entry, position = cost(next_open, 1), 1
        elif signal == -1 and position == 1:
            cash += cost(next_open, -1) - entry
            position = 0

    print(f"Bars: {len(rows)}  Realised PnL: {cash:.4f}")


if __name__ == "__main__":
    asyncio.run(backtest("btc-above-100k-june", MeanRevert()))

// Module 12, A Minimal Event-Driven Backtester
// Data: GET /markets/{slug}/oracle-candles (public, Chainlink OHLCV)
// Fill: next bar's open + configurable slippage. No look-ahead.

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "time"
)

const (
    base     = "https://api.limitless.exchange"
    feeBps   = 20 // from /profiles/{account}.rank.feeRateBps
    slipBps  = 15 // calibrated from /portfolio/trades
)

type Row struct {
    Timestamp int64   `json:"timestamp"`
    Open      float64 `json:"open"`
    High      float64 `json:"high"`
    Low       float64 `json:"low"`
    Close     float64 `json:"close"`
    Volume    float64 `json:"volume"`
}

type candlesResp struct {
    Rows []Row `json:"rows"`
}

type Strategy interface{ OnTick(r Row, position int) int }

type MeanRevert struct{ history []float64 }

func (s *MeanRevert) OnTick(r Row, position int) int {
    s.history = append(s.history, r.Close)
    if len(s.history) < 20 {
        return 0
    }
    var sum float64
    for _, v := range s.history[len(s.history)-20:] {
        sum += v
    }
    mean := sum / 20
    if r.Close < mean*0.97 && position <= 0 {
        return 1
    }
    if r.Close > mean*1.03 && position >= 0 {
        return -1
    }
    return 0
}

func fetchCandles(slug string, from, to int64) ([]Row, error) {
    url := fmt.Sprintf("%s/markets/%s/oracle-candles?interval=1h&from=%d&to=%d",
        base, slug, from, to)
    resp, err := http.Get(url)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    var data candlesResp
    if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
        return nil, err
    }
    return data.Rows, nil
}

func cost(px float64, side int) float64 {
    return px * (1 + float64(side)*float64(feeBps+slipBps)/10_000)
}

func main() {
    now  := time.Now().Unix()
    from := now - 30*24*60*60

    rows, err := fetchCandles("btc-above-100k-june", from, now)
    if err != nil {
        log.Fatal(err)
    }

    var cash, entry float64
    var position int
    strat := &MeanRevert{}

    for i := 0; i < len(rows)-1; i++ {
        signal   := strat.OnTick(rows[i], position)
        nextOpen := rows[i+1].Open // fill at next bar's open
        if signal == 1 && position == 0 {
            entry, position = cost(nextOpen, 1), 1
        } else if signal == -1 && position == 1 {
            cash += cost(nextOpen, -1) - entry
            position = 0
        }
    }
    fmt.Printf("Bars: %d  Realised PnL: %.4f\n", len(rows), cash)
}