Complete reference for the model code editor.

import { ModelDefinition, Params, defineParameters } from "@/lib/models";

export const model: ModelDefinition = {
  id: "sma-cross",
  name: "SMA Cross",
  version: "1.0.0",
  timeframe: "1h",
  parameters: defineParameters({
    market: Params.market({
      default: { id: "TOKEN_OR_TICKER", provider: "polymarket" },
      description: "Market to trade",
    }),
    fast: Params.integer({ default: 10, min: 2, max: 100 }),
    slow: Params.integer({ default: 30, min: 5, max: 200 }),
    size: Params.number({ default: 50, min: 1, max: 1000 }),
  }),
  defaultState: { last: "flat" as "flat" | "long" | "short" },
  async onBar(ctx) {
    const { params, orders, state, setState } = ctx;
    const series = ctx.getSeries();
    const fast = series.sma(params.fast);
    const slow = series.sma(params.slow);
    if (!fast || !slow) return;

    if (fast > slow && state.last !== "long") {
      setState({ last: "long" });
      return orders.buy(params.size, { tag: "sma-long" });
    }
    if (fast < slow && state.last !== "short") {
      setState({ last: "short" });
      return orders.sell(params.size, { tag: "sma-short" });
    }
  },
};

export default model;

import { ModelDefinition, Params, defineParameters } from "@/lib/models";

export const model: ModelDefinition = {
  id: "poly-search-demo",
  name: "Polymarket Search Demo",
  version: "1.0.0",
  timeframe: "1h",
  parameters: defineParameters({
    marketSearch: Params.string({
      default: "election",
      description: "Search term used by the backtest to pick an event.",
    }),
    minVolume24h: Params.number({
      default: 1000,
      min: 0,
      description: "Minimum 24h volume filter.",
    }),
    size: Params.number({ default: 50, min: 1, max: 1000 }),
  }),
  defaultState: {
    selectedMarketId: null as string | null,
    selectedEventId: null as string | null,
  },
  async initialize(ctx) {
    const { events } = await ctx.data.searchPolymarket({
      search: ctx.params.marketSearch,
      status: "open",
      sortBy: "volume_24h",
      sortOrder: "desc",
      minVolume24h: ctx.params.minVolume24h,
      limit: 50,
    });

    const top = events[0];
    if (!top) {
      ctx.log("No Polymarket results", {
        query: ctx.params.marketSearch,
        minVolume24h: ctx.params.minVolume24h,
      });
      return;
    }

    // Switch to the top event's leading market
    await ctx.setMarket(top.leading);

    ctx.setState({
      selectedMarketId: top.leading.descriptor.id,
      selectedEventId: top.id,
    });
  },
  async onBar(ctx) {
    const price = ctx.series.close();
    const prev = ctx.series.close(1);
    if (!price || !prev) return;

    if (price > prev) {
      return ctx.orders.buy(ctx.params.size, { tag: "search-buy" });
    }
  },
};

export default model;

const tf: Timeframe = "1h";

const candle: Candle = {
  timestamp: Date.now(),
  open: 0.55,
  high: 0.6,
  low: 0.52,
  close: 0.58,
  volume: 1200,
};

const env: Environment = "backtest";

const market: MarketDescriptor = {
  id: "123456",
  provider: "polymarket",
  ticker: "ELECTION24",
};

const value: MaybePromise<number> = Promise.resolve(42);

const summary: ModelSummary = {
  id: "mean-reversion-v1",
  name: "Mean Reversion",
  version: "1.0.0",
  timeframe: "1h",
  parameters: [{ key: "lookback", kind: "integer", default: 20 }],
};

const spec: BaseParamSpec<number> = { kind: "number", default: 1, description: "Example" };

const spec: NumberParamSpec = { kind: "number", default: 0.02, min: 0, max: 1, unit: "pct" };

const spec: BooleanParamSpec = { kind: "boolean", default: true, description: "Enable filter" };

const spec: StringParamSpec = { kind: "string", default: "BTC", placeholder: "Ticker" };

const spec: EnumParamSpec<"buy" | "sell"> = {
  kind: "enum",
  default: "buy",
  options: ["buy", "sell"] as const,
};

const spec: MarketParamSpec = {
  kind: "market",
  default: { id: "123", provider: "polymarket" },
};

const spec: ParamSpec = { kind: "integer", default: 14, min: 1, max: 100 };

const params: ParamMap = {
  lookback: { kind: "integer", default: 20 },
  enabled: { kind: "boolean", default: true },
};

type MyParams = ResolvedParams<{ size: NumberParamSpec; enabled: BooleanParamSpec }>;

type SizeValue = InferParamType<NumberParamSpec>; // number

const spec = numberParam({ default: 0.5, min: 0, max: 1, unit: "pct" });

const spec = integerParam({ default: 20, min: 5, max: 200 });

const spec = booleanParam({ default: true, description: "Enable filter" });

const spec = stringParam({ default: "BTC", placeholder: "Ticker" });

const spec = enumParam({ default: "buy", options: ["buy", "sell"] as const });

const spec = marketParam({ default: { id: "TOKEN_OR_TICKER", provider: "polymarket" } });

const parameters = {
  lookback: Params.integer({ default: 20, min: 5, max: 200 }),
  size: Params.number({ default: 100, min: 1, max: 10000, unit: "contracts" }),
};

const lookback = defineParameter(Params.integer({ default: 20, min: 5, max: 200 }));

const params = defineParameters({
  size: Params.number({ default: 100, min: 1, max: 10000 }),
});

const def: ModelDefinition = {
  id: "example",
  name: "Example",
  version: "1.0.0",
  timeframe: "1h",
  onBar: async (ctx) => ctx.log("tick"),
};

const handler: ModelHandler<any, any> = (ctx) => ctx.orders.exit();

async function initialize(ctx: ModelContext<any, any>) {
  const { events } = await ctx.data.searchPolymarket({ search: "polymarket" });
  if (events[0]) await ctx.setMarket(events[0].leading);
}

const history = await ctx.data.priceHistory({
  market: ctx.market,
  interval: "1d",
});

const { markets, events } = await ctx.data.searchPolymarket({
  search: "election",
  limit: 5,
  sortBy: "volume_24h",
});
const topMarket = markets[0]?.market;
const topEvent = events[0];

const field: PolymarketMarketSortField = "volume_24h";

const field: PolymarketEventSortField = "volume_24h";

const opts: PolymarketSearchParams = { search: "election", limit: 10 };

const { events } = await ctx.data.searchPolymarket({ search: "election" });
const firstEvent = events[0];
const mainMarket = firstEvent.leading.descriptor;

const action = ctx.orders.buy(50, { tag: "entry", kind: "market" });

const reader = provider.getSeries("alt");

const series = ctx.getSeries();
const price = series.close();
const prev = series.close(1);
const high20 = series.highest(20);

const series = new Series(candles, () => cursor);
const price = series.close();

const action: OrderAction = {
  type: "order",
  side: "buy",
  size: 100,
  price: 0.58,
  kind: "limit",
  tag: "entry",
};

const action: AlertAction = {
  type: "alert",
  level: "warning",
  message: "Low liquidity",
  meta: { spread: 0.12 },
};

const action: StateAction<{ last: string }> = {
  type: "state",
  patch: { last: "long" },
};

const action: ModelAction = ctx.orders.exit();

const position: PositionState = {
  size: 100,
  avgPrice: 0.45,
  unrealizedPnl: 12.5,
  realizedPnl: -2.0,
};

const portfolio: PortfolioState = {
  cash: 9800,
  equity: 10120,
  positions: { size: 100, avgPrice: 0.5, unrealizedPnl: 20, realizedPnl: 0 },
  feesPaid: 2.1,
  fills: [],
};

const fill: Fill = {
  timestamp: Date.now(),
  price: 0.62,
  size: 100,
  side: "buy",
  fee: 0.062,
};

const trade: TradeRecord = {
  timestamp: Date.now(),
  price: 0.62,
  size: 100,
  side: "buy",
  pnl: 5.4,
  equity: 10025,
};

const options: RuntimeOptions = { env: "backtest", initialCash: 5000 };

const runtime = new ModelRuntime(model, candles, params, { initialCash: 10000 });
const result = await runtime.run();

const options: BacktestOptions = { initialCash: 25000 };

const result = await runBacktest(model, candles, { market: { id: "123", provider: "polymarket" } });

const result = await backtestFromPayload({ modelId: "x", params: { size: 100 } }, model, candles);

const payload: BacktestRequestPayload = {
  modelId: "mean-reversion-v1",
  params: { lookback: 30 },
  timeframe: "1h",
  start: Date.parse("2024-01-01T00:00:00Z"),
  end: Date.parse("2024-02-01T00:00:00Z"),
};

const result: BacktestResult = {
  modelId: "x",
  timeframe: "1h",
  stats: { netProfit: 120, returnPct: 0.012, maxDrawdown: 0.04, winRate: 0.5, trades: 10 },
  equityCurve: [],
  trades: [],
  params: {},
};

registerModel(model);

const models = listModels();

const model = getModel("mean-reversion-v1");

const result = loadModelFromCode(code);
if ("error" in result) {
  console.error(result.error);
} else {
  registerModel(result.model);
}

const params = parseModelParameters(code);
// => [{ key: "lookback", kind: "integer", default: 20 }]

const parsed: ParsedParam = { key: "size", kind: "number", default: 100, description: "Contracts" };

const candles = await source.fetchCandles({
  market: { id: "123", provider: "polymarket" },
  timeframe: "1h",
});

const source = new KalshiCandleSource(kalshiClient);
const candles = await source.fetchCandles({ market, timeframe: "1h" });

const source = new PolymarketCandleSource(polyClient);
const candles = await source.fetchCandles({ market, timeframe: "1h" });

const source = new MemoryCandleSource({
  BTC: candles,
});
const out = await source.fetchCandles({ market: { id: "BTC", provider: "generic" }, timeframe: "1h" });

const ms = timeframeToMs("1h");

const [first] = BASE_METHODS;
// => { name: "getSeries()", description: "Get the default series reader..." }

const code = defaultTemplate("My Model", "4h");

registerModel(meanReversionModel);

registerModel(breakoutModel);

registerBuiltinModels();