写一个策略

for each market-day in your scope (sharded across workers)
  on_market_open(ctx, market)     ← state resets here
  for each event in event-time order:
    on_tick / on_book / on_trade  ← you may return an Order
  on_settle(ctx, market, outcome) ← official label arrives last

# the ot CLI — check / run / submit (node 24, ESM only)
npm i -g outcometick@1.6.7

# writing in Python? add this for type hints in your editor.
# it does NOT contain ot — the line above is what gives you the command.
pip install outcometick==1.6.7

from outcometick import Strategy, Order


class MeanReversion(Strategy):
    def on_market_open(self, ctx, market):
        self.entered = False

    def on_tick(self, ctx, tick):
        # tick.value is the settlement feed's price, as a float
        z = ctx.zscore(tick.value, window=180)
        if self.entered or abs(z) < ctx.p.entry_z:
            return None

        side = "DOWN" if z > 0 else "UP"
        book = ctx.book(tick.market_id)
        if book.depth(side) < ctx.p.min_depth:
            return None

        self.entered = True
        return Order(side=side, notional=ctx.p.notional,
                     limit=book.best(side),
                     hold_s=ctx.p.hold_minutes * 60)

{
  "schema": 1,
  "language": "python@3.14",
  "entry": "strategy.py:MeanReversion",
  "hooks": ["on_market_open", "on_tick"],
  "datasets": ["settlement", "book"],
  "deps": ["numpy"],
  "params": {
    "entry_z": 2.0,
    "hold_minutes": 20,
    "notional": 200,
    "min_depth": 2000
  }
}

  "reference": ["binance:btcusdt:spot:1s"],
  "series": [{ "name": "my_signal", "file": "signal.csv" }]

# both are read-only and aligned to event time
spot = ctx.ref("binance:btcusdt:spot:1s").last
basis = tick.value - spot.close
mine = ctx.ext("my_signal").at(ctx.now)

{
  "schema": 1,
  "language": "python@3.14",
  "entry": "strategy.py:Basis",
  "hooks": ["on_market_open", "on_tick"],
  "datasets": ["settlement", "book"],
  "reference": ["binance:btcusdt:spot:1s"],
  "params": { "lookback_s": 30, "min_drift": 0.0004, "max_px": 0.6, "notional": 80 }
}

from outcometick import Strategy, Order


class Basis(Strategy):
    """Fade the market when it disagrees with Binance spot momentum."""

    def on_market_open(self, ctx, market):
        self.done = False

    def on_tick(self, ctx, tick):
        if self.done:
            return None

        spot = ctx.ref("binance:btcusdt:spot:1s")
        # Enough history to measure momentum over. Early in a market-day there
        # is not any, and None is what you get -- not a zero, and not a bar
        # borrowed from after ctx.now.
        bars = spot.window(ctx.p.lookback_s)
        if len(bars) < ctx.p.lookback_s:
            return None

        drift = (bars[-1].close - bars[0].close) / bars[0].close
        if abs(drift) < ctx.p.min_drift:
            return None

        # Spot is going up, so the market saying "down" is the side to take.
        side = "UP" if drift > 0 else "DOWN"
        book = ctx.book(tick.market_id)
        px = book.best(side)
        if px is None or px > ctx.p.max_px:
            return None

        self.done = True
        ctx.log(f"drift {drift:+.4%} over {ctx.p.lookback_s}s -> {side} at {px}")
        return Order(side=side, notional=ctx.p.notional, limit=px)

ts_ms,score,confidence
1786536000000,0.62,0.91
1786536060000,0.58,0.88
1786536120000,0.71,0.95

{
  "schema": 1,
  "language": "python@3.14",
  "entry": "strategy.py:Signal",
  "hooks": ["on_tick"],
  "datasets": ["settlement", "prices", "twap30s", "twap60s", "book", "bbo", "trades", "markets"],
  "series": [{ "name": "my_signal", "file": "signal.csv", "lag_ms": 300000 }],
  "params": { "min_score": 0.6, "notional": 80 }
}

from outcometick import Strategy, Order


class Signal(Strategy):
    def on_tick(self, ctx, tick):
        row = ctx.ext("my_signal").last
        # None until the first row is BOTH stamped and past its lag_ms. The
        # column names are your CSV's own -- ts_ms is ours, the rest is yours.
        if row is None or row.score < ctx.p.min_score:
            return None

        book = ctx.book(tick.market_id)
        px = book.best("UP")
        if px is None:
            return None
        return Order(side="UP", notional=ctx.p.notional, limit=px)

def on_market_open(self, ctx, market):
    self.close_ts = market.close_ts_ms
    self.done = False

def on_tick(self, ctx, tick):
    secs_left = (self.close_ts - ctx.now) / 1000
    if self.done or secs_left > ctx.p.enter_at_s:
        return None

    ask = ctx.book(tick.market_id).best(ctx.p.side)
    if not ctx.p.px_min <= ask <= ctx.p.px_max:
        return None

    self.done = True
    return Order(side=ctx.p.side, notional=ctx.p.notional, limit=ask)

def on_tick(self, ctx, tick):
    secs_left = (self.close_ts - ctx.now) / 1000
    if self.done or secs_left > ctx.p.enter_at_s:
        return None

    # Momentum on the underlying, straight off the settlement stream —
    # the same Chainlink prints this market settles on. No outside feed,
    # and nothing to align: it is the series you are already being fed.
    past = ctx.history(ctx.p.lookback_s + 1)
    if len(past) <= ctx.p.lookback_s:
        return None
    mom = tick.value / past[0].value - 1

    if abs(mom) < ctx.p.mom_threshold:
        return None

    side = "UP" if mom > 0 else "DOWN"
    ask  = ctx.book(tick.market_id).best(side)
    if ask is None or not ctx.p.px_min <= ask <= ctx.p.px_max:
        return None

    self.done = True
    return Order(side=side, notional=ctx.p.notional, limit=ask)

def on_book(self, ctx, event):
    book = ctx.book()  # the event is the change; this is the book it produced
    edge = ctx.p.fair - book.best("UP")   # your signal
    pos  = ctx.position()

    # flat, and the edge is worth crossing for
    if pos.size == 0 and edge > ctx.p.entry_edge:
        return Order(side="UP", size=ctx.p.clip, limit=book.best("UP"))

    # edge gone — flatten
    if pos.size > 0 and edge < ctx.p.exit_edge:
        return Order(side="UP", size=pos.size, reduce_only=True,
                     limit=book.best_bid("UP"), tag="exit")

    # signal flipped — close and reverse in one event
    if pos.size > 0 and edge < -ctx.p.entry_edge:
        return [
            Order(side="UP", size=pos.size, reduce_only=True, limit=book.best_bid("UP")),
            Order(side="DOWN", size=ctx.p.clip, limit=book.best("DOWN")),
        ]

    return None

my-strategy/
  outcometick.json     # the manifest: language, entry, hooks, datasets, params
  strategy.py          # the file `entry` points at, holding the `entry` class
  helpers.py           # split it up if you like
  signal.csv           # your own series, declared under `series`

# python: import your own files RELATIVELY, or the validator rejects them —
#   from .helpers import cheaper      ✓
#   from helpers import cheaper       ✗ E_IMPORT: not on the allowlist
# node:   import { cheaper } from "./helpers.mjs";

# the directory IS the submission — that is what the "." refers to
ot check  ./my-strategy
ot submit ./my-strategy --assets btc --from 2026-07-14 --to 2026-08-12 --venue polymarket

# one day of real files, free, no key needed
curl -L https://github.com/Ligengxin96/polymarket-data-samples/releases/latest/download/polymarket-data-samples.tar.gz | tar xz

# validate the manifest and hook signatures — no data touched, no key needed
ot check .

# replay locally, same runner, same report format
ot run . --data ./polymarket-data-samples

# the key travels in the environment, never in a flag:
# a flag lands in shell history and in the process list, and this key spends money
export OT_BACKTEST_KEY=bt_...

# submit to the queue against the full archive
ot submit . --assets btc,eth --from 2026-07-14 --to 2026-08-12

# where it got to, and what it actually cost
ot status run_...

# download the archive once it is done
ot fetch run_...