resolvedkit 0.1.0__py3-none-any.whl

resolvedkit/__init__.py

@@ -0,0 +1,13 @@
+"""Backtest Polymarket strategies against the real order book."""
+from .data import ParquetSource, ResolvedMarketsAPI, load_sample, write_parquet
+from .engine import Backtester, Context, MarketResult, Strategy
+from .fees import taker_fee
+from .metrics import Results
+from .models import DOWN, UP, Book, Fill, Level, Market
+from .rules import RuleStrategy
+
+__version__ = "0.1.0"
+__all__ = [
+    "Backtester", "Book", "Context", "DOWN", "Fill", "Level", "Market", "MarketResult", "ParquetSource",
+    "ResolvedMarketsAPI", "Results", "RuleStrategy", "Strategy", "UP", "load_sample", "taker_fee", "write_parquet",
+]

resolvedkit/cli.py

@@ -0,0 +1,85 @@
+"""resolvedkit run spec.json [--data sample|api|<folder>] [--compare-mid] [--json]"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from .engine import Backtester
+from .rules import RuleStrategy
+
+
+def _source(args):
+    if args.data == "sample":
+        from .data import load_sample
+
+        return load_sample()
+    if args.data == "api":
+        from .data import ResolvedMarketsAPI
+
+        return ResolvedMarketsAPI(crypto=args.crypto, timeframe=args.timeframe, category=args.category,
+                                  since=args.since, before=args.before, limit=args.limit, thin_ms=args.thin_ms)
+    from .data import ParquetSource
+
+    return ParquetSource(args.data)
+
+
+def _spec_path(name: str):
+    """A path to a JSON spec, or the name of a bundled example such as `late_favorite`."""
+    from importlib.resources import files
+    from pathlib import Path
+
+    p = Path(name)
+    if p.exists():
+        return p
+    bundled = files("resolvedkit") / "specs" / f"{p.stem}.json"
+    if bundled.is_file():
+        return bundled
+    examples = sorted(x.name.removesuffix(".json") for x in (files("resolvedkit") / "specs").iterdir())
+    raise SystemExit(f"No spec file '{name}'. Bundled examples: {', '.join(examples)}")
+
+
+def _print(label: str, s: dict) -> None:
+    print(f"\n{label}")
+    for k, v in s.items():
+        print(f"  {k:<22} {v}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(prog="resolvedkit", description="Backtest Polymarket strategies against the real order book.")
+    sub = p.add_subparsers(dest="cmd", required=True)
+    run = sub.add_parser("run", help="run a JSON strategy spec")
+    run.add_argument("spec", help="path to a JSON strategy spec, or a bundled example: late_favorite, early_underdog_scalp")
+    run.add_argument("--data", default="sample", help="'sample' (bundled, default), 'api' (Resolved Markets), or a Parquet folder")
+    run.add_argument("--latency-ms", type=int, default=250)
+    run.add_argument("--compare-mid", action="store_true", help="also run with mid-price fills and show the difference")
+    run.add_argument("--json", action="store_true", help="print results as JSON")
+    for flag in ("--crypto", "--timeframe", "--category", "--since", "--before"):
+        run.add_argument(flag, help="with --data api: filter markets like /v1/markets/history/recent")
+    run.add_argument("--limit", type=int, default=20, help="with --data api: number of markets")
+    run.add_argument("--thin-ms", type=int, default=None, help="with --data api: keep one snapshot per side per interval")
+    args = p.parse_args(argv)
+
+    spec = json.loads(_spec_path(args.spec).read_text())
+    data = _source(args)
+    markets = data.markets()
+    book = Backtester(data, RuleStrategy(spec), latency_ms=args.latency_ms).run(markets).summary()
+    out = {"strategy": spec.get("name", args.spec), "book": book}
+    if args.compare_mid:
+        out["mid"] = Backtester(data, RuleStrategy(spec), latency_ms=args.latency_ms, fill_model="mid").run(markets).summary()
+    if args.json:
+        json.dump(out, sys.stdout, indent=2)
+        print()
+        return 0
+    print(f"Strategy: {out['strategy']}  ({len(markets)} markets)")
+    _print("Fills against the real order book:", book)
+    if args.compare_mid:
+        _print("Same strategy with mid-price fills (unrealistic):", out["mid"])
+        rm, rb = out["mid"]["return_on_invested"], book["return_on_invested"]
+        if rm is not None and rb is not None:
+            print(f"\nReturn on money invested: {rm:+.1%} with mid-price fills vs {rb:+.1%} on the real book.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

resolvedkit/data/__init__.py

@@ -0,0 +1,7 @@
+"""Data sources. Anything with `markets()` and `books(market_id)` can drive a backtest."""
+from .base import DataSource
+from .parquet import ParquetSource, write_parquet
+from .resolvedmarkets import ResolvedMarketsAPI
+from .sample import load_sample
+
+__all__ = ["DataSource", "ParquetSource", "ResolvedMarketsAPI", "load_sample", "write_parquet"]

resolvedkit/data/base.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Protocol
+
+from ..models import Book, Market
+
+TIMEFRAME_MS = {"5m": 300_000, "15m": 900_000, "1h": 3_600_000, "4h": 14_400_000, "1d": 86_400_000}
+
+
+class DataSource(Protocol):
+    def markets(self) -> list[Market]:
+        """Markets to backtest over, oldest first."""
+        ...
+
+    def books(self, market_id: str) -> list[Book]:
+        """Every order-book snapshot for both outcome tokens of one market, in time order."""
+        ...
+
+
+def parse_ts(value: str | int | float) -> int:
+    """API timestamps are UTC strings like '2026-09-28 13:15:15.955'; return epoch ms."""
+    if isinstance(value, (int, float)):
+        return int(value)
+    dt = datetime.fromisoformat(value.replace("Z", "+00:00").replace(" ", "T"))
+    dt = dt.replace(tzinfo=timezone.utc) if dt.tzinfo is None else dt.astimezone(timezone.utc)
+    return int(dt.timestamp() * 1000)
+
+
+def thin(books: list[Book], every_ms: int) -> list[Book]:
+    """Keep the last snapshot per side in each `every_ms` bucket. Book state at bucket ends is exact."""
+    last: dict[tuple[str, int], Book] = {}
+    for b in books:
+        last[(b.side, b.ts // every_ms)] = b
+    return sorted(last.values(), key=lambda b: (b.ts, b.side))

resolvedkit/data/parquet.py

@@ -0,0 +1,88 @@
+"""A local dataset: two Parquet files in one folder.
+
+markets.parquet  market_id, slug, question, category, timeframe, start_ts, end_ts,
+                 outcome_up, outcome_down, payout_up, payout_down   (payouts null if unresolved)
+books.parquet    market_id, ts (epoch ms UTC), side ("UP"/"DOWN"),
+                 bid_px, bid_sz, ask_px, ask_sz   (lists, best level first)
+
+Any source of Polymarket order books can be converted to this layout and backtested.
+"""
+from __future__ import annotations
+
+from collections import defaultdict
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+from ..models import Book, Level, Market
+
+_MARKET_SCHEMA = pa.schema([
+    ("market_id", pa.string()), ("slug", pa.string()), ("question", pa.string()),
+    ("category", pa.string()), ("timeframe", pa.string()),
+    ("start_ts", pa.int64()), ("end_ts", pa.int64()),
+    ("outcome_up", pa.string()), ("outcome_down", pa.string()),
+    ("payout_up", pa.float64()), ("payout_down", pa.float64()),
+])
+_BOOK_SCHEMA = pa.schema([
+    ("market_id", pa.string()), ("ts", pa.int64()), ("side", pa.string()),
+    ("bid_px", pa.list_(pa.float64())), ("bid_sz", pa.list_(pa.float64())),
+    ("ask_px", pa.list_(pa.float64())), ("ask_sz", pa.list_(pa.float64())),
+])
+
+
+class ParquetSource:
+    def __init__(self, folder: str | Path):
+        self.folder = Path(folder)
+        self._books: dict[str, list[Book]] | None = None
+
+    def markets(self) -> list[Market]:
+        rows = pq.read_table(self.folder / "markets.parquet").to_pylist()
+        out = []
+        for r in rows:
+            payout = None
+            if r["payout_up"] is not None and r["payout_down"] is not None:
+                payout = (r["payout_up"], r["payout_down"])
+            out.append(Market(
+                market_id=r["market_id"], question=r["question"], category=r["category"],
+                end_ts=r["end_ts"], outcomes=(r["outcome_up"], r["outcome_down"]), payout=payout,
+                start_ts=r["start_ts"], slug=r["slug"], timeframe=r["timeframe"],
+            ))
+        return sorted(out, key=lambda m: m.end_ts)
+
+    def books(self, market_id: str) -> list[Book]:
+        if self._books is None:
+            grouped: dict[str, list[Book]] = defaultdict(list)
+            for r in pq.read_table(self.folder / "books.parquet").to_pylist():
+                grouped[r["market_id"]].append(Book(
+                    ts=r["ts"], side=r["side"],
+                    bids=tuple(Level(p, s) for p, s in zip(r["bid_px"], r["bid_sz"])),
+                    asks=tuple(Level(p, s) for p, s in zip(r["ask_px"], r["ask_sz"])),
+                ))
+            for v in grouped.values():
+                v.sort(key=lambda b: (b.ts, b.side))
+            self._books = dict(grouped)
+        return self._books.get(market_id, [])
+
+
+def write_parquet(folder: str | Path, markets: list[Market], books: dict[str, list[Book]], depth: int | None = None) -> None:
+    """Save markets and their books in the layout ParquetSource reads. `depth` keeps the top N levels."""
+    folder = Path(folder)
+    folder.mkdir(parents=True, exist_ok=True)
+    pq.write_table(pa.Table.from_pylist([{
+        "market_id": m.market_id, "slug": m.slug, "question": m.question, "category": m.category,
+        "timeframe": m.timeframe, "start_ts": m.start_ts, "end_ts": m.end_ts,
+        "outcome_up": m.outcomes[0], "outcome_down": m.outcomes[1],
+        "payout_up": m.payout[0] if m.payout else None, "payout_down": m.payout[1] if m.payout else None,
+    } for m in markets], schema=_MARKET_SCHEMA), folder / "markets.parquet", compression="zstd")
+    rows = []
+    for market_id, bs in books.items():
+        for b in bs:
+            bids = b.bids if depth is None else b.bids[:depth]
+            asks = b.asks if depth is None else b.asks[:depth]
+            rows.append({
+                "market_id": market_id, "ts": b.ts, "side": b.side,
+                "bid_px": [l.price for l in bids], "bid_sz": [l.size for l in bids],
+                "ask_px": [l.price for l in asks], "ask_sz": [l.size for l in asks],
+            })
+    pq.write_table(pa.Table.from_pylist(rows, schema=_BOOK_SCHEMA), folder / "books.parquet", compression="zstd")

resolvedkit/data/resolvedmarkets.py

@@ -0,0 +1,91 @@
+"""Historical Polymarket order books from the Resolved Markets API (https://resolvedmarkets.com).
+
+A free API key covers crypto up/down markets (the 5 most recent per coin and timeframe);
+paid plans unlock full history and other categories. Set RESOLVED_MARKETS_API_KEY or pass api_key=.
+"""
+from __future__ import annotations
+
+import os
+import time
+
+import requests
+
+from ..models import DOWN, UP, Book, Level, Market
+from .base import TIMEFRAME_MS, parse_ts, thin
+
+BASE_URL = "https://api.resolvedmarkets.com"
+PAGE = 500
+
+
+class ResolvedMarketsAPI:
+    def __init__(self, api_key: str | None = None, *, crypto: str | None = None, timeframe: str | None = None,
+                 category: str | None = None, since: str | None = None, before: str | None = None,
+                 limit: int = 20, thin_ms: int | None = None, depth: int | None = None, base_url: str = BASE_URL):
+        """Select closed markets like `/v1/markets/history/recent` does, e.g. crypto="BTC", timeframe="15m".
+
+        thin_ms keeps one snapshot per side per interval (1000 = one per second) to cut memory;
+        depth keeps only the top N levels of each side.
+        """
+        key = api_key or os.environ.get("RESOLVED_MARKETS_API_KEY")
+        if not key:
+            raise ValueError("Set RESOLVED_MARKETS_API_KEY or pass api_key= (free key: https://resolvedmarkets.com/api-keys)")
+        self.session = requests.Session()
+        self.session.headers["X-API-Key"] = key
+        self.base_url = base_url
+        self.query = {k: v for k, v in {"crypto": crypto, "timeframe": timeframe, "category": category,
+                                         "since": since, "before": before, "status": "closed"}.items() if v}
+        self.limit, self.thin_ms, self.depth = limit, thin_ms, depth
+        self._markets: list[Market] | None = None
+
+    def _get(self, path: str, **params) -> dict:
+        for attempt in range(4):
+            r = self.session.get(self.base_url + path, params=params, timeout=60)
+            if r.status_code == 429 or r.status_code >= 500:
+                time.sleep(2 ** attempt)
+                continue
+            if r.status_code == 403 and "replay_locked" in r.text:
+                raise PermissionError(f"{path}: this market is outside the free tier's replay window (upgrade for full history)")
+            r.raise_for_status()
+            return r.json()
+        r.raise_for_status()
+        return r.json()
+
+    def markets(self) -> list[Market]:
+        if self._markets is None:
+            rows = self._get("/v1/markets/history/recent", **self.query, limit=self.limit)["markets"]
+            out = []
+            for row in rows:
+                if row.get("replay_locked"):
+                    continue
+                meta = self._get("/v1/markets/metadata", market_id=row["market_id"])["markets"][0]
+                prices = meta.get("outcome_prices")
+                payout = (float(prices[0]), float(prices[1])) if meta.get("resolution_status") == "resolved" and prices else None
+                end_ts = parse_ts(meta["end_date"])
+                tf = meta.get("timeframe") or ""
+                out.append(Market(
+                    market_id=row["market_id"], question=meta.get("question") or "", category=meta.get("category") or "",
+                    end_ts=end_ts, outcomes=tuple(meta.get("outcomes") or ("Up", "Down")), payout=payout,
+                    start_ts=end_ts - TIMEFRAME_MS[tf] if tf in TIMEFRAME_MS else None,
+                    slug=meta.get("slug") or "", timeframe=tf,
+                ))
+            self._markets = sorted(out, key=lambda m: m.end_ts)
+        return self._markets
+
+    def books(self, market_id: str) -> list[Book]:
+        books: list[Book] = []
+        for side in (UP, DOWN):
+            offset = 0
+            while True:
+                page = self._get(f"/v1/markets/{market_id}/snapshots", side=side, includebook="true", order="asc",
+                                 count="false", limit=PAGE, offset=offset)["data"]
+                for s in page:
+                    bids = tuple(Level(l["price"], l["size"]) for l in s.get("bids") or ())
+                    asks = tuple(Level(l["price"], l["size"]) for l in s.get("asks") or ())
+                    if self.depth is not None:
+                        bids, asks = bids[: self.depth], asks[: self.depth]
+                    books.append(Book(ts=parse_ts(s["timestamp"]), side=side, bids=bids, asks=asks))
+                if len(page) < PAGE:
+                    break
+                offset += PAGE
+        books.sort(key=lambda b: (b.ts, b.side))
+        return thin(books, self.thin_ms) if self.thin_ms else books

resolvedkit/data/sample.py

@@ -0,0 +1,14 @@
+"""The bundled sample: settled BTC 15-minute Polymarket markets with full-depth books.
+
+Data © Resolved Markets, licensed CC BY 4.0 (see DATA_LICENSE). Books are thinned to one snapshot per
+side per second and the top 20 levels, which keeps the package small; the API serves every snapshot.
+"""
+from __future__ import annotations
+
+from importlib.resources import files
+
+from .parquet import ParquetSource
+
+
+def load_sample() -> ParquetSource:
+    return ParquetSource(files("resolvedkit") / "sample_data")

resolvedkit/engine.py

@@ -0,0 +1,208 @@
+"""The event loop: replay each market's books in time order, execute orders against the book, settle."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Literal
+
+from .fees import rate_for
+from .fills import walk_buy, walk_sell
+from .models import DOWN, SIDES, UP, Book, Fill, Market, Position
+
+FillModel = Literal["book", "mid"]
+
+
+@dataclass
+class Order:
+    side: str
+    action: str  # BUY or SELL
+    submit_ts: int
+    usd: float | None = None  # BUY size
+    shares: float | None = None  # SELL size; None = the whole position
+    limit: float | None = None  # max price for BUY, min price for SELL
+
+
+@dataclass
+class Rejection:
+    order: Order
+    reason: str  # placeholder_book, no_liquidity, price_limit, no_position, invalid_size
+
+
+@dataclass
+class MarketResult:
+    market: Market
+    fills: list[Fill] = field(default_factory=list)
+    rejections: list[Rejection] = field(default_factory=list)
+    settlement: float = 0.0  # USDC received for shares held at resolution
+    resolved: bool = True
+
+    @property
+    def fees(self) -> float:
+        return sum(f.fee for f in self.fills)
+
+    @property
+    def pnl(self) -> float:
+        cash = sum(-f.notional if f.action == "BUY" else f.notional for f in self.fills)
+        return cash + self.settlement - self.fees
+
+    @property
+    def traded(self) -> bool:
+        return bool(self.fills)
+
+
+class Context:
+    """What a strategy sees and does during one market."""
+
+    def __init__(self, market: Market, engine: "Backtester"):
+        self.market = market
+        self._engine = engine
+        self.now = 0
+        self.books: dict[str, Book] = {}
+        self.positions = {s: Position(s) for s in SIDES}
+        self.pending: list[Order] = []
+        self.state: dict = {}  # scratch space for the strategy, reset per market
+
+    @property
+    def seconds_to_end(self) -> float:
+        return (self.market.end_ts - self.now) / 1000
+
+    def book(self, side: str) -> Book | None:
+        return self.books.get(side)
+
+    def position(self, side: str) -> Position:
+        return self.positions[side]
+
+    def buy(self, side: str, usd: float, max_price: float | None = None) -> None:
+        """Marketable buy for `usd` of the side's token, filled after the engine's latency."""
+        self.pending.append(Order(side, "BUY", self.now, usd=usd, limit=max_price))
+
+    def pending_orders(self, side: str | None = None) -> list[Order]:
+        """Orders placed but not yet filled or rejected."""
+        return [o for o in self.pending if side is None or o.side == side]
+
+    def sell(self, side: str, shares: float | None = None, min_price: float | None = None) -> None:
+        """Marketable sell of `shares` (default: the whole position)."""
+        self.pending.append(Order(side, "SELL", self.now, shares=shares, limit=min_price))
+
+
+class Strategy:
+    """Subclass and override `on_book`. Called for every snapshot of either side, in time order."""
+
+    def on_start(self, ctx: Context) -> None:
+        pass
+
+    def on_book(self, ctx: Context, book: Book) -> None:
+        raise NotImplementedError
+
+    def on_end(self, ctx: Context) -> None:
+        pass
+
+
+class Backtester:
+    def __init__(self, data, strategy: Strategy, *, latency_ms: int = 250, fill_model: FillModel = "book",
+                 fee_rate: float | None = None, skip_placeholder_books: bool = True):
+        """
+        latency_ms: an order fills against the book standing `latency_ms` after it was placed, i.e. the
+            latest snapshot of that token at or before that moment.
+        fill_model: "book" walks the ladder (default). "mid" fills the whole order at the mid price with no
+            depth limit — unrealistic, provided only to measure how much a mid-price backtest overstates.
+        fee_rate: override Polymarket's taker rate for the market's category.
+        skip_placeholder_books: reject orders against 0.01/0.99 placeholder books.
+        """
+        self.data, self.strategy = data, strategy
+        self.latency_ms, self.fill_model = latency_ms, fill_model
+        self.fee_rate, self.skip_placeholder_books = fee_rate, skip_placeholder_books
+
+    def run(self, markets: list[Market] | None = None) -> "Results":
+        from .metrics import Results
+
+        results = [self._run_market(m) for m in (markets if markets is not None else self.data.markets())]
+        return Results(results, fill_model=self.fill_model, latency_ms=self.latency_ms)
+
+    def _run_market(self, market: Market) -> MarketResult:
+        res = MarketResult(market)
+        ctx = Context(market, self)
+        rate = self.fee_rate if self.fee_rate is not None else rate_for(market.category)
+        self.strategy.on_start(ctx)
+        for book in self.data.books(market.market_id):
+            # Orders due before this snapshot fill against the books standing at their due time...
+            self._execute_due(ctx, res, rate, before=book.ts)
+            ctx.now = book.ts
+            ctx.books[book.side] = book
+            # ...and orders due exactly now see this snapshot too.
+            self._execute_due(ctx, res, rate, before=book.ts + 1)
+            self.strategy.on_book(ctx, book)
+        self.strategy.on_end(ctx)
+        # Orders still pending after the last snapshot fill against the final standing books.
+        self._execute_due(ctx, res, rate, before=None)
+        for side in SIDES:
+            pos = ctx.positions[side]
+            if pos.shares > 1e-9:
+                payout = market.payout_for(side)
+                if payout is None:  # unresolved: mark at the last mid so PnL is still defined
+                    res.resolved = False
+                    last = ctx.books.get(side)
+                    payout = last.mid if last else 0.0
+                res.settlement += pos.shares * payout
+        return res
+
+    def _execute_due(self, ctx: Context, res: MarketResult, rate: float, before: int | None) -> None:
+        """Execute pending orders whose due time is earlier than `before` (all of them if None)."""
+        still = []
+        for o in ctx.pending:
+            due = o.submit_ts + self.latency_ms
+            if before is not None and due >= before:
+                still.append(o)
+                continue
+            book = ctx.books.get(o.side)
+            if book is None:
+                res.rejections.append(Rejection(o, "no_liquidity"))
+                continue
+            if self.skip_placeholder_books and book.is_placeholder:
+                res.rejections.append(Rejection(o, "placeholder_book"))
+                continue
+            pos = ctx.positions[o.side]
+            fill = self._fill(o, pos, book, rate, due)
+            if isinstance(fill, str):
+                res.rejections.append(Rejection(o, fill))
+                continue
+            if o.action == "BUY":
+                pos.shares += fill.shares
+                pos.cost += fill.notional
+            else:
+                avg_cost = pos.cost / pos.shares if pos.shares else 0.0
+                pos.cost -= avg_cost * fill.shares
+                pos.shares -= fill.shares
+            pos.fees += fill.fee
+            pos.fills.append(fill)
+            res.fills.append(fill)
+        ctx.pending = still
+
+    def _fill(self, o: Order, pos: Position, book: Book, rate: float, ts: int) -> Fill | str:
+        if o.action == "BUY" and (o.usd is None or o.usd <= 0):
+            return "invalid_size"
+        if o.action == "SELL":
+            want = pos.shares if o.shares is None else min(o.shares, pos.shares)
+            if want <= 1e-9:
+                return "no_position"
+        if not (book.asks if o.action == "BUY" else book.bids):
+            return "no_liquidity"  # same rule for both fill models, so --compare-mid compares like with like
+        if self.fill_model == "mid":
+            price = book.mid
+            if o.action == "BUY":
+                if o.limit is not None and price > o.limit:
+                    return "price_limit"
+                shares = o.usd / price if price > 0 else 0.0
+            else:
+                if o.limit is not None and price < o.limit:
+                    return "price_limit"
+                shares = want
+            fee = round(shares * rate * price * (1 - price), 5)
+            return Fill(o.side, o.action, ts, shares, price, fee, book.mid)
+        walk = walk_buy(book.asks, o.usd, o.limit) if o.action == "BUY" else walk_sell(book.bids, want, o.limit)
+        if walk.shares <= 1e-9:
+            return "price_limit"
+        return Fill(o.side, o.action, ts, walk.shares, walk.avg_price, walk.fee(rate), book.mid, walk.depth_limited)
+
+
+def other(side: str) -> str:
+    return DOWN if side == UP else UP

resolvedkit/fees.py

@@ -0,0 +1,34 @@
+"""Polymarket taker fees.
+
+fee = shares × rate × p × (1 − p), charged to the taker only, rounded to 5 decimals.
+Rates by category from https://docs.polymarket.com/trading/fees (checked 2026-09-28).
+Polymarket changes these; pass `rate=` to override.
+"""
+from __future__ import annotations
+
+TAKER_FEE_RATES: dict[str, float] = {
+    "crypto": 0.07,
+    "sports": 0.05,
+    "finance": 0.04,
+    "equities": 0.04,
+    "politics": 0.04,
+    "economics": 0.05,
+    "culture": 0.05,
+    "weather": 0.05,
+    "social": 0.05,
+    "mentions": 0.04,
+    "tech": 0.04,
+    "geopolitics": 0.0,
+}
+DEFAULT_RATE = 0.05  # Polymarket's "Other / General"
+
+
+def rate_for(category: str) -> float:
+    return TAKER_FEE_RATES.get((category or "").lower(), DEFAULT_RATE)
+
+
+def taker_fee(shares: float, price: float, rate: float) -> float:
+    """Fee in USDC for a taker fill of `shares` at `price`."""
+    if shares <= 0 or rate <= 0:
+        return 0.0
+    return round(shares * rate * price * (1.0 - price), 5)

resolvedkit/fills.py

@@ -0,0 +1,64 @@
+"""Fill simulation: walk the order book level by level, as a real marketable order would."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .models import Level
+
+
+@dataclass(frozen=True)
+class WalkResult:
+    legs: tuple[Level, ...]  # (price, shares) actually taken at each level
+    depth_limited: bool  # stopped early: book exhausted or price limit reached
+
+    @property
+    def shares(self) -> float:
+        return sum(l.size for l in self.legs)
+
+    @property
+    def cost(self) -> float:
+        """USDC paid (buy) or received (sell), before fees."""
+        return sum(l.size * l.price for l in self.legs)
+
+    @property
+    def avg_price(self) -> float:
+        s = self.shares
+        return self.cost / s if s else 0.0
+
+    def fee(self, rate: float) -> float:
+        """Polymarket charges each match at its own price: Σ shares × rate × p × (1 − p)."""
+        return round(sum(l.size * rate * l.price * (1 - l.price) for l in self.legs), 5)
+
+
+def walk_buy(asks: tuple[Level, ...], usd: float, max_price: float | None = None) -> WalkResult:
+    """Spend up to `usd` lifting asks from the best price up, never paying above `max_price`."""
+    legs, spent = [], 0.0
+    for lvl in asks:
+        if lvl.price <= 0 or lvl.size <= 0:
+            continue
+        remaining = usd - spent
+        if remaining <= 1e-9:
+            break
+        if max_price is not None and lvl.price > max_price + 1e-12:
+            return WalkResult(tuple(legs), True)
+        take = min(lvl.size, remaining / lvl.price)
+        legs.append(Level(lvl.price, take))
+        spent += take * lvl.price
+    return WalkResult(tuple(legs), usd - spent > 1e-6)
+
+
+def walk_sell(bids: tuple[Level, ...], shares: float, min_price: float | None = None) -> WalkResult:
+    """Sell up to `shares` into bids from the best price down, never selling below `min_price`."""
+    legs, sold = [], 0.0
+    for lvl in bids:
+        if lvl.size <= 0:
+            continue
+        remaining = shares - sold
+        if remaining <= 1e-9:
+            break
+        if min_price is not None and lvl.price < min_price - 1e-12:
+            return WalkResult(tuple(legs), True)
+        take = min(lvl.size, remaining)
+        legs.append(Level(lvl.price, take))
+        sold += take
+    return WalkResult(tuple(legs), shares - sold > 1e-6)

resolvedkit/metrics.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .engine import MarketResult
+
+
+@dataclass
+class Results:
+    markets: list[MarketResult]
+    fill_model: str = "book"
+    latency_ms: int = 0
+
+    @property
+    def traded(self) -> list[MarketResult]:
+        return [m for m in self.markets if m.traded]
+
+    @property
+    def pnl(self) -> float:
+        return sum(m.pnl for m in self.markets)
+
+    @property
+    def fees(self) -> float:
+        return sum(m.fees for m in self.markets)
+
+    @property
+    def invested(self) -> float:
+        return sum(f.notional for m in self.markets for f in m.fills if f.action == "BUY")
+
+    @property
+    def win_rate(self) -> float | None:
+        t = self.traded
+        return sum(m.pnl > 0 for m in t) / len(t) if t else None
+
+    @property
+    def slippage_vs_mid(self) -> float | None:
+        """Average cost of trading against the book instead of the mid, in price units (0.01 = 1¢).
+
+        Positive means worse than mid: paid above it on buys, received below it on sells.
+        """
+        fills = [f for m in self.markets for f in m.fills]
+        if not fills:
+            return None
+        signed = [(f.avg_price - f.mid_at_fill) * (1 if f.action == "BUY" else -1) * f.shares for f in fills]
+        return sum(signed) / sum(f.shares for f in fills)
+
+    @property
+    def brier(self) -> float | None:
+        """Brier score of the first entry price as a probability forecast of the side bought winning.
+
+        Measures how well the market's price (as you traded it) predicted the outcome. Lower is better;
+        always buying at 0.5 scores 0.25.
+        """
+        pairs = []
+        for m in self.markets:
+            buys = [f for f in m.fills if f.action == "BUY"]
+            if buys and m.market.payout is not None:
+                first = buys[0]
+                pairs.append((first.avg_price, m.market.payout_for(first.side)))
+        return sum((p - o) ** 2 for p, o in pairs) / len(pairs) if pairs else None
+
+    @property
+    def rejections(self) -> dict[str, int]:
+        out: dict[str, int] = {}
+        for m in self.markets:
+            for r in m.rejections:
+                out[r.reason] = out.get(r.reason, 0) + 1
+        return out
+
+    def equity_curve(self) -> list[tuple[int, float]]:
+        """Cumulative PnL after each market settles, as (end_ts, pnl)."""
+        total, out = 0.0, []
+        for m in sorted(self.markets, key=lambda r: r.market.end_ts):
+            total += m.pnl
+            out.append((m.market.end_ts, total))
+        return out
+
+    def summary(self) -> dict:
+        def r(x, n=4):
+            return None if x is None else round(x, n)
+
+        return {
+            "fill_model": self.fill_model,
+            "latency_ms": self.latency_ms,
+            "markets": len(self.markets),
+            "markets_traded": len(self.traded),
+            "invested_usd": r(self.invested, 2),
+            "pnl_usd": r(self.pnl, 2),
+            "return_on_invested": r(self.pnl / self.invested if self.invested else None),
+            "fees_usd": r(self.fees, 2),
+            "win_rate": r(self.win_rate),
+            "partial_fills": sum(f.depth_limited for m in self.markets for f in m.fills),
+            "avg_slippage_vs_mid": r(self.slippage_vs_mid),
+            "entry_brier": r(self.brier),
+            "rejected_orders": self.rejections,
+            "unresolved_markets": sum(not m.resolved for m in self.traded),
+        }

resolvedkit/models.py

@@ -0,0 +1,103 @@
+"""Core data types. Prices are probabilities in [0, 1]; sizes are shares; money is USDC."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+
+UP, DOWN = "UP", "DOWN"
+SIDES = (UP, DOWN)
+
+
+@dataclass(frozen=True)
+class Level:
+    price: float
+    size: float
+
+
+@dataclass(frozen=True)
+class Book:
+    """One order-book snapshot for one outcome token.
+
+    `bids` are sorted best (highest) first, `asks` best (lowest) first. An empty side means
+    nobody was quoting it, which happens near settlement.
+    """
+
+    ts: int  # epoch milliseconds, UTC
+    side: str  # UP or DOWN: UP is the market's first outcome (e.g. "Up" or "Yes")
+    bids: tuple[Level, ...]
+    asks: tuple[Level, ...]
+
+    @property
+    def best_bid(self) -> float | None:
+        return self.bids[0].price if self.bids else None
+
+    @property
+    def best_ask(self) -> float | None:
+        return self.asks[0].price if self.asks else None
+
+    @property
+    def mid(self) -> float:
+        """Polymarket's convention: a missing bid counts as 0 and a missing ask as 1."""
+        return ((self.best_bid or 0.0) + (self.best_ask if self.best_ask is not None else 1.0)) / 2
+
+    @property
+    def two_sided(self) -> bool:
+        return bool(self.bids) and bool(self.asks)
+
+    @property
+    def is_placeholder(self) -> bool:
+        """A freshly listed market often shows a 0.01 bid / 0.99 ask before real quoting starts.
+
+        Trading against it in a backtest buys at 0.99 or sells at 0.01, which no one would do.
+        """
+        return (self.best_bid or 0.0) <= 0.01 and (self.best_ask if self.best_ask is not None else 1.0) >= 0.99
+
+
+@dataclass(frozen=True)
+class Market:
+    market_id: str
+    question: str
+    category: str
+    end_ts: int  # epoch ms: expiry for crypto up/down, kickoff for sports
+    outcomes: tuple[str, str] = ("Up", "Down")
+    # Settlement value per share of each side, e.g. (1.0, 0.0). None while unresolved.
+    payout: tuple[float, float] | None = None
+    start_ts: int | None = None  # window start for recurring markets, when known
+    slug: str = ""
+    timeframe: str = ""
+
+    def payout_for(self, side: str) -> float | None:
+        if self.payout is None:
+            return None
+        return self.payout[0] if side == UP else self.payout[1]
+
+
+@dataclass
+class Fill:
+    side: str  # UP or DOWN token
+    action: str  # BUY or SELL
+    ts: int
+    shares: float
+    avg_price: float
+    fee: float
+    mid_at_fill: float
+    depth_limited: bool = False  # the book (or the price limit) could not absorb the full order
+
+    @property
+    def notional(self) -> float:
+        return self.shares * self.avg_price
+
+
+@dataclass
+class Position:
+    side: str
+    shares: float = 0.0
+    cost: float = 0.0  # USDC paid for the shares still held, excluding fees
+    fees: float = 0.0
+    fills: list[Fill] = field(default_factory=list)
+
+
+def ms_to_dt(ms: int) -> datetime:
+    from datetime import timezone
+
+    return datetime.fromtimestamp(ms / 1000, tz=timezone.utc)

resolvedkit/rules.py

@@ -0,0 +1,81 @@
+"""Strategies from a JSON spec, so a backtest can be written without Python (or by an AI agent).
+
+{
+  "name": "late favorite",
+  "entry": {
+    "side": "favorite",            // UP, DOWN, favorite (higher mid) or underdog (lower mid)
+    "seconds_before_end": 120,      // enter once this close to the market's end time
+    "min_price": 0.6, "max_price": 0.9,   // only if the side's best ask is in this range
+    "usd": 100,                     // order size
+    "max_slippage": 0.02            // never pay more than best ask + this
+  },
+  "exit": {                         // optional; without it the position is held to resolution
+    "take_profit": 0.05,            // sell when the best bid is this far above the entry price
+    "stop_loss": 0.10               // sell when the best bid is this far below it
+  }
+}
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .engine import Context, Strategy
+from .models import DOWN, UP, Book
+
+_SIDES = {"UP", "DOWN", "favorite", "underdog"}
+EPS = 1e-9  # price comparisons: 0.52 + 0.05 is 0.5700000000000001 in floating point
+
+
+@dataclass
+class RuleStrategy(Strategy):
+    spec: dict
+
+    def __post_init__(self):
+        e = self.spec.get("entry") or {}
+        if e.get("side") not in _SIDES:
+            raise ValueError(f"entry.side must be one of {sorted(_SIDES)}")
+        for k in ("seconds_before_end", "usd"):
+            if not isinstance(e.get(k), (int, float)) or e[k] <= 0:
+                raise ValueError(f"entry.{k} must be a positive number")
+
+    def on_start(self, ctx: Context) -> None:
+        ctx.state.update(side=None)
+
+    def _pick_side(self, ctx: Context) -> str | None:
+        want = self.spec["entry"]["side"]
+        if want in (UP, DOWN):
+            return want
+        up, down = ctx.book(UP), ctx.book(DOWN)
+        if not up or not down:
+            return None
+        fav = UP if up.mid >= down.mid else DOWN
+        return fav if want == "favorite" else (DOWN if fav == UP else UP)
+
+    def on_book(self, ctx: Context, book: Book) -> None:
+        # State comes from fills, not from orders placed: a rejected or partial order is retried.
+        e, x, st = self.spec["entry"], self.spec.get("exit") or {}, ctx.state
+        if ctx.pending_orders():
+            return
+        side = st["side"]
+        entered = side is not None and any(f.action == "BUY" for f in ctx.position(side).fills)
+        if not entered:
+            if not (0 < ctx.seconds_to_end <= e["seconds_before_end"]):
+                return
+            side = self._pick_side(ctx)
+            b = ctx.book(side) if side else None
+            if not b or b.best_ask is None:
+                return
+            if not (e.get("min_price", 0.0) - EPS <= b.best_ask <= e.get("max_price", 1.0) + EPS):
+                return
+            ctx.buy(side, e["usd"], max_price=b.best_ask + e.get("max_slippage", 0.02))
+            st["side"] = side
+            return
+        pos = ctx.position(side)
+        if pos.shares <= 1e-9 or book.side != side or not x or book.best_bid is None:
+            return
+        entry = pos.cost / pos.shares
+        bid = book.best_bid
+        if ("take_profit" in x and bid >= entry + x["take_profit"] - EPS) or (
+            "stop_loss" in x and bid <= entry - x["stop_loss"] + EPS
+        ):
+            ctx.sell(side)

resolvedkit/specs/early_underdog_scalp.json

@@ -0,0 +1,5 @@
+{
+  "name": "Buy the underdog with 10 minutes left, take 5 cents or stop at 10",
+  "entry": {"side": "underdog", "seconds_before_end": 600, "min_price": 0.3, "max_price": 0.5, "usd": 250, "max_slippage": 0.02},
+  "exit": {"take_profit": 0.05, "stop_loss": 0.10}
+}

resolvedkit/specs/late_favorite.json

@@ -0,0 +1,4 @@
+{
+  "name": "Buy the favorite in the last 2 minutes, hold to resolution",
+  "entry": {"side": "favorite", "seconds_before_end": 120, "min_price": 0.6, "max_price": 0.9, "usd": 250, "max_slippage": 0.02}
+}

resolvedkit-0.1.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.5
+Name: resolvedkit
+Version: 0.1.0
+Summary: A Polymarket backtester that tests strategies against the real order book. Fills walk the L2 ladder, fees follow Polymarket's curve, positions settle at resolution.
+Project-URL: Homepage, https://github.com/resolvedmarkets/resolvedkit
+Project-URL: Data, https://resolvedmarkets.com
+Project-URL: Issues, https://github.com/resolvedmarkets/resolvedkit/issues
+Author-email: Resolved Markets <info@resolvedmarkets.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: backtesting,orderbook,polymarket,polymarket-backtester,prediction-markets,quant,trading
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.10
+Requires-Dist: pyarrow>=14
+Requires-Dist: requests>=2.31
+Provides-Extra: dev
+Requires-Dist: matplotlib>=3.7; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.7; extra == 'plot'
+Description-Content-Type: text/markdown
+
+# resolvedkit: a Polymarket backtester
+
+**Backtest Polymarket strategies against the real order book.** Orders fill by walking the L2 ladder,
+fees follow Polymarket's taker-fee curve, orders land after a realistic delay, and positions settle at
+the market's actual resolution. It ships with sample data, so it runs straight after `pip install`, with
+no API key.
+
+![Same strategy backtested with mid-price fills and on the real order book](https://raw.githubusercontent.com/resolvedmarkets/resolvedkit/main/docs/mid-vs-book.png)
+
+Most prediction-market backtests fill at the mid price. That price is not one you can trade at: a
+market buy pays the ask, walks up the book when the size is larger than the best level, and pays a
+taker fee on top. On the bundled sample, the same strategy with the same fees returns **+29.5%** when
+filled at the mid and **+26.0%** when filled against the book. That gap is often an entire edge.
+
+```bash
+pip install resolvedkit
+resolvedkit run late_favorite --compare-mid
+```
+
+## What it models
+
+- **Book-walking fills.** Buys lift asks level by level and sells hit bids. A price limit caps the
+  walk, and partial fills are flagged when the book runs out. Mid-price fills exist only as an explicit
+  `fill_model="mid"`, to measure how much they overstate.
+- **Polymarket fees.** `shares × rate × p × (1 − p)` is charged per matched level, with the rate for
+  each category (crypto 0.07, sports 0.05, and so on).
+- **Latency.** An order fills against the book standing `latency_ms` after it was placed (250 ms by
+  default), not the book that triggered it.
+- **Settlement.** Shares still held at the end pay out the market's resolved price, 1 or 0 per share, or
+  a fraction for split outcomes. Unresolved markets are marked at the last mid and counted in
+  `unresolved_markets`.
+- **Placeholder books.** Freshly listed markets often show a 0.01 / 0.99 book before real quoting
+  starts. Orders against it are rejected rather than filled at 0.99.
+- **Metrics.** Results include PnL, return on money invested, fees, win rate, partial fills, average
+  slippage against the mid, and the Brier score of entry prices.
+
+## Two ways to write a strategy
+
+**JSON spec**, with no code, which also makes it easy for an AI agent to write one:
+
+```json
+{
+  "name": "Buy the favorite in the last 2 minutes, take 5 cents or stop at 10",
+  "entry": {"side": "favorite", "seconds_before_end": 120, "min_price": 0.6, "max_price": 0.9,
+            "usd": 250, "max_slippage": 0.02},
+  "exit": {"take_profit": 0.05, "stop_loss": 0.10}
+}
+```
+
+`side` is `UP`, `DOWN`, `favorite` or `underdog`. Without `exit`, the position is held to resolution.
+Save it as `my_strategy.json` and run `resolvedkit run my_strategy.json`. Two examples are
+bundled: `late_favorite` and `early_underdog_scalp`.
+
+**Python**, for anything else:
+
+```python
+from resolvedkit import UP, Backtester, Strategy, load_sample
+
+class DepthImbalance(Strategy):
+    def on_book(self, ctx, book):
+        if book.side != UP or ctx.state.get("entered") or not book.two_sided:
+            return
+        bid_depth = sum(l.size * l.price for l in book.bids[:5])
+        ask_depth = sum(l.size * l.price for l in book.asks[:5])
+        if 60 < ctx.seconds_to_end < 600 and bid_depth > 3 * ask_depth:
+            ctx.buy(UP, usd=100, max_price=book.best_ask + 0.02)
+            ctx.state["entered"] = True
+
+print(Backtester(load_sample(), DepthImbalance()).run().summary())
+```
+
+`on_book` is called for every snapshot of either outcome token, in time order. `ctx` provides:
+- `book(side)`, `position(side)`, `now` and `seconds_to_end`
+- `buy(side, usd, max_price)` and `sell(side, shares, min_price)`
+- `state`, a dict that resets for each market
+
+## Data
+
+| Source | Use |
+|---|---|
+| `load_sample()` | 18 settled BTC 15-minute markets, bundled (CC BY 4.0) |
+| `ResolvedMarketsAPI(crypto="BTC", timeframe="15m", limit=50)` | Historical Polymarket order books from [Resolved Markets](https://resolvedmarkets.com). A free API key covers recent crypto markets; paid plans add full history plus sports, weather, equities and economics. |
+| `ParquetSource("folder/")` | Your own data in the documented [two-file Parquet layout](https://github.com/resolvedmarkets/resolvedkit/blob/main/src/resolvedkit/data/parquet.py) |
+
+```bash
+export RESOLVED_MARKETS_API_KEY=rm_...   # free key: https://resolvedmarkets.com/api-keys
+resolvedkit run late_favorite --data api --crypto ETH --timeframe 5m --limit 50
+```
+
+The sample is thinned to one snapshot per side per second and the top 20 levels. The API serves every
+snapshot at full depth.
+
+## Honest limits
+
+- Rejected or partly filled orders are retried by the JSON rules on the next snapshot; in Python
+  strategies, check `ctx.pending_orders()` and your position yourself.
+- Your orders don't move the book: each fill walks the snapshot as recorded, and later snapshots don't
+  reflect your trades. For small size relative to depth this is close; for large size it's optimistic.
+- Resting (maker) orders aren't simulated yet, since queue position isn't in snapshot data. All fills
+  are taker fills.
+- 18 sample markets are enough to show the mechanics, not to prove a strategy. Run on hundreds.
+
+## Roadmap
+
+Kalshi fees and data adapter · maker orders with queue estimates · wallet-replay (copy-trading)
+backtests · an MCP server so agents can run backtests.
+
+## License
+
+Code: MIT. Sample data: CC BY 4.0, see [DATA_LICENSE](https://github.com/resolvedmarkets/resolvedkit/blob/main/DATA_LICENSE).

resolvedkit-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+resolvedkit/__init__.py,sha256=pZhDkpabHDkI3VIgYYuq2E3AOVqSeGcAzTJ0txHzqs0,613
+resolvedkit/cli.py,sha256=NFa35VPiHYb37gICo5eNEhQ1PkKJBIVYe2zBtMHWck8,3695
+resolvedkit/engine.py,sha256=4HQAsSDRJwSPhek0ON-vVdDgrrGBfuSivYi0lVOF1bA,8679
+resolvedkit/fees.py,sha256=U8pZiv7E5iuro-r_8idXXP8ncrmX8q0FAz8RfztU8tU,996
+resolvedkit/fills.py,sha256=2K3QqyjUdF3tUX42q4PuUL3nvYWjJ0YsVNKVNtHv2l4,2337
+resolvedkit/metrics.py,sha256=nerIqATQH0p6G0WVAHIhoCCRtNzb8N2WqacBdq5n7Pk,3456
+resolvedkit/models.py,sha256=H5YRQTceeXIz93h-DQsisabEeJbXpO-XBfkdwgeddKE,3039
+resolvedkit/rules.py,sha256=oq-VSN2iHUgt-oOyN9kaExzGv0aMosJmzHVO6zTJwVU,3329
+resolvedkit/data/__init__.py,sha256=eI7F-9Pewjgr2M3XqoQ4k29lYD3RCj5sqJo8vOOl_ZI,347
+resolvedkit/data/base.py,sha256=1gs8NS7WA7UaPBA0OO4Nnj1ZzQGxt1CPDS3Gtzkd5RU,1287
+resolvedkit/data/parquet.py,sha256=tX-M7183Ift4I1OwpV6ifSqeu_TPJZ7-RW4FWECTthE,4200
+resolvedkit/data/resolvedmarkets.py,sha256=QYzY0-0uTReCnZMq_nFieuPBkR3oaBl_HAO1ZB8YDXI,4641
+resolvedkit/data/sample.py,sha256=f2rkl96gT4mp8HevSmm3cvPraHubDSvG_Syzz7xqKjY,507
+resolvedkit/sample_data/books.parquet,sha256=6gzpEOhBFnxHxHDXgEa7tNmu_YWpC1RJOZ9dupPdENY,2647815
+resolvedkit/sample_data/markets.parquet,sha256=CcHMzjIL-cBGO3sFbPbYSCg94ORj2bZuukF-2cyNq8c,4966
+resolvedkit/specs/early_underdog_scalp.json,sha256=Y6cHSqVk74YnIWufREdPJE_99ph7BXTYSXqnfpzwffg,264
+resolvedkit/specs/late_favorite.json,sha256=E90jCrKiAkjyzGKHhBhMGy8MsOaYyiNo00er6NH5b4s,205
+resolvedkit-0.1.0.dist-info/METADATA,sha256=h34eXzTf4FCzIqJN2hv59r4DJLZ2wkTJ15SErecwIiE,6703
+resolvedkit-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+resolvedkit-0.1.0.dist-info/entry_points.txt,sha256=PeddVi_9U9M6epogejAzNfGkLvhb0ziYZ0PUY41M2kI,53
+resolvedkit-0.1.0.dist-info/licenses/LICENSE,sha256=TxXjZsKMxudOqfCxFZyCzocJSjcSdQzwVNAA2_zEiAo,1089
+resolvedkit-0.1.0.dist-info/RECORD,,

resolvedkit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

resolvedkit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+resolvedkit = resolvedkit.cli:main

resolvedkit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Elcara LLC-FZ (Resolved Markets)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.