pmfees 0.1.0__py3-none-any.whl

pmfees/__init__.py

@@ -0,0 +1,26 @@
+"""pmfees: exact trading fees for Kalshi, Polymarket US and polymarket.com.
+
+All rates, tiers, multipliers and rounding rules come from ``prediction_market_fees.json``
+(bundled, or your own file via ``load_rates(path)`` / ``PMFEES_RATES_FILE``).
+"""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+from .core import PLATFORMS, BreakEven, FeeResult, break_even, fee, platform_key
+from .rates import Rates, RatesError, default_rates, load_rates
+
+__all__ = [
+    "PLATFORMS",
+    "BreakEven",
+    "FeeResult",
+    "Rates",
+    "RatesError",
+    "__version__",
+    "break_even",
+    "default_rates",
+    "fee",
+    "load_rates",
+    "platform_key",
+]

pmfees/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

pmfees/cli.py

@@ -0,0 +1,177 @@
+"""Command line: ``pmfees kalshi --price 0.50 --contracts 100``."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Sequence
+from decimal import Decimal
+
+from . import __version__
+from .core import BreakEven, FeeResult, break_even, fee
+from .rates import Rates, RatesError, load_rates
+
+
+def _money(d: Decimal) -> str:
+    # Show at least cents, more when the platform rounds finer (polymarket.com: 5 decimals).
+    exp = d.normalize().as_tuple().exponent
+    places = max(2, -exp if isinstance(exp, int) else 2)
+    return f"${d:,.{places}f}"
+
+
+def _price(d: Decimal) -> str:
+    return f"{(d * 100).normalize():f}¢"
+
+
+def _render_fee(r: FeeResult) -> str:
+    pct = r.fee_pct_of_trade_value
+    pct_s = "" if pct is None else f" ({pct.quantize(Decimal('0.01'))}% of trade value at {_price(r.price)})"
+    lines = [
+        f"{r.platform_name} {r.role} fee: {_money(r.fee)}{pct_s}",
+        f"  {r.side} {r.contracts.normalize():f} contracts at {_money(r.price)}"
+        f" = {_money(r.trade_value)} trade value",
+    ]
+    for k, v in r.details.items():
+        lines.append(f"  {k.replace('_', ' ')}: {v}")
+    lines.append(
+        f"  {r.coefficient.normalize():f} × {r.contracts.normalize():f} × {r.price.normalize():f}"
+        f" × (1 − {r.price.normalize():f}) = {r.raw_fee.normalize():f}, {r.rounding}: {_money(r.fee)}"
+    )
+    lines += [f"  note: {n}" for n in r.notes]
+    lines.append(f"  rates as of {r.rates_as_of} · source: {r.source_url}")
+    return "\n".join(lines)
+
+
+def _render_break_even(b: BreakEven) -> str:
+    verb = "rise" if b.side == "buy" else "fall"
+    if b.exit_price is None or b.move is None or b.exit_fee is None or b.profit_at_exit is None:
+        return (
+            f"Break-even: no exit price below $1 puts this {b.side} in profit after fees ({b.platform_name})."
+        )
+    return (
+        f"Break-even: the price must {verb} {abs(b.move * 100).normalize():f}¢ "
+        f"to {_price(b.exit_price)} (tick {_price(b.tick)}); "
+        f"entry fee {_money(b.entry_fee)} + exit fee {_money(b.exit_fee)}, "
+        f"profit at that price {_money(b.profit_at_exit)}"
+    )
+
+
+def _parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="pmfees",
+        description="Exact trading fees for Kalshi, Polymarket US and polymarket.com.",
+    )
+    p.add_argument("--version", action="version", version=f"pmfees {__version__}")
+    sub = p.add_subparsers(dest="platform", required=True, metavar="PLATFORM")
+
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--price", required=True, help="contract price in dollars, e.g. 0.50")
+    common.add_argument("--contracts", required=True, help="number of contracts (shares)")
+    common.add_argument("--side", choices=("buy", "sell"), default="buy")
+    common.add_argument("--maker", action="store_true", help="maker order instead of taker")
+    common.add_argument("--break-even", action="store_true", help="also show the break-even price move")
+    common.add_argument("--tick", default="0.01", help="price step for --break-even (default 0.01)")
+    common.add_argument("--json", action="store_true", help="print JSON instead of text")
+    common.add_argument("--rates", help="path to an updated prediction_market_fees.json")
+
+    k = sub.add_parser("kalshi", parents=[common], help="Kalshi")
+    k.add_argument("--multiplier", help="fee multiplier M (default 1 for takers, 0 for makers)")
+
+    us = sub.add_parser("polymarket-us", parents=[common], help="Polymarket US")
+    grp = us.add_mutually_exclusive_group()
+    grp.add_argument("--tier", help="taker tier 1-4, or 'new' for the first 7 days (default 1)")
+    grp.add_argument("--volume", help="trailing 30-day taker volume in USD (picks the tier)")
+
+    g = sub.add_parser("polymarket", parents=[common], help="polymarket.com (international)")
+    g.add_argument("--category", required=True, help="market category, e.g. Crypto, Sports, Politics")
+
+    r = sub.add_parser("rates", help="show the loaded rates and their date")
+    r.add_argument("--rates", help="path to an updated prediction_market_fees.json")
+    return p
+
+
+def _rates_summary(rates: Rates) -> str:
+    g, us, k = rates.polymarket_global, rates.polymarket_us, rates.kalshi
+    lines = [f"Rates current as of {rates.as_of} ({rates.path})", "", f"Kalshi ({k.source_url})"]
+    lines.append(
+        f"  taker {k.taker_rate}, maker {k.maker_rate}, series multipliers "
+        f"{', '.join(str(m) for m in k.multipliers)}; {k.rounding.describe()}"
+    )
+    lines += ["", f"Polymarket US ({us.source_url}, effective {us.effective})"]
+    for t in us.tiers:
+        rng = f"below ${t.below:,}" if t.below is not None else "the rest"
+        lines.append(f"  {t.label}: Θ {t.theta} (30-day taker volume {rng})")
+    lines.append(f"  New account: Θ {us.new_account_theta}; {us.rounding.describe()}")
+    lines += ["", f"polymarket.com ({g.source_url})"]
+    lines += [f"  {cat}: {rate}" for cat, rate in g.rates.items()]
+    lines.append(f"  {g.rounding.describe()}")
+    return "\n".join(lines)
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    try:
+        rates = load_rates(args.rates)
+        if args.platform == "rates":
+            print(_rates_summary(rates))
+            return 0
+        opts: dict[str, str | None] = {
+            "multiplier": getattr(args, "multiplier", None),
+            "tier": getattr(args, "tier", None),
+            "volume_30d": getattr(args, "volume", None),
+            "category": getattr(args, "category", None),
+        }
+        result = fee(
+            args.platform,
+            args.price,
+            args.contracts,
+            args.side,
+            opts["tier"],
+            args.maker,
+            category=opts["category"],
+            multiplier=opts["multiplier"],
+            volume_30d=opts["volume_30d"],
+            rates=rates,
+        )
+        be = None
+        if args.break_even:
+            be = break_even(
+                args.platform,
+                args.price,
+                args.contracts,
+                args.side,
+                opts["tier"],
+                args.maker,
+                tick=args.tick,
+                category=opts["category"],
+                multiplier=opts["multiplier"],
+                volume_30d=opts["volume_30d"],
+                rates=rates,
+            )
+    except (ValueError, ArithmeticError, RatesError, OSError) as exc:
+        print(f"pmfees: error: {exc}", file=sys.stderr)
+        return 2
+
+    if args.json:
+        out: dict[str, object] = {"fee": result.breakdown(), "notes": list(result.notes)}
+        if be is not None:
+            out["break_even"] = {
+                "entry_price": str(be.entry_price),
+                "exit_price": None if be.exit_price is None else str(be.exit_price),
+                "move": None if be.move is None else str(be.move),
+                "entry_fee_usd": str(be.entry_fee),
+                "exit_fee_usd": None if be.exit_fee is None else str(be.exit_fee),
+                "profit_at_exit_usd": None if be.profit_at_exit is None else str(be.profit_at_exit),
+                "tick": str(be.tick),
+            }
+        print(json.dumps(out, indent=2, ensure_ascii=False))
+    else:
+        print(_render_fee(result))
+        if be is not None:
+            print(_render_break_even(be))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pmfees/core.py

@@ -0,0 +1,373 @@
+"""Fee and break-even calculations for Kalshi, Polymarket US and polymarket.com."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from decimal import Decimal
+from typing import Literal
+
+from .rates import Rates, Rounding, default_rates
+
+Platform = Literal["kalshi", "polymarket-us", "polymarket"]
+Side = Literal["buy", "sell"]
+Number = Decimal | int | float | str
+
+PLATFORMS: tuple[Platform, ...] = ("kalshi", "polymarket-us", "polymarket")
+
+_ALIASES: dict[str, Platform] = {
+    "kalshi": "kalshi",
+    "polymarket-us": "polymarket-us",
+    "polymarket_us": "polymarket-us",
+    "pm-us": "polymarket-us",
+    "polymarket": "polymarket",
+    "polymarket.com": "polymarket",
+    "polymarket-global": "polymarket",
+    "polymarket_global": "polymarket",
+}
+
+DISPLAY_NAMES: dict[Platform, str] = {
+    "kalshi": "Kalshi",
+    "polymarket-us": "Polymarket US",
+    "polymarket": "polymarket.com",
+}
+
+ONE = Decimal(1)
+
+
+def _num(value: Number, what: str) -> Decimal:
+    if isinstance(value, bool):
+        raise TypeError(f"{what} must be a number")
+    # str() first so 0.1 (float) becomes Decimal("0.1"), not its binary expansion.
+    d = value if isinstance(value, Decimal) else Decimal(str(value))
+    if not d.is_finite():
+        raise ValueError(f"{what} must be finite")
+    return d
+
+
+def platform_key(platform: str) -> Platform:
+    key = _ALIASES.get(platform.strip().lower())
+    if key is None:
+        raise ValueError(f"unknown platform {platform!r}; use one of: {', '.join(PLATFORMS)}")
+    return key
+
+
+@dataclass(frozen=True)
+class FeeResult:
+    """A fee in USD with everything that went into it."""
+
+    platform: Platform
+    platform_name: str
+    side: Side
+    role: Literal["taker", "maker"]
+    price: Decimal
+    contracts: Decimal
+    coefficient: Decimal
+    """The coefficient applied in coefficient × C × p × (1 − p), multipliers included."""
+    raw_fee: Decimal
+    """Exact fee before the platform's rounding."""
+    fee: Decimal
+    """Fee in USD after the platform's rounding (what you pay)."""
+    rounding: str
+    formula: str
+    source_url: str
+    rates_as_of: str
+    details: dict[str, str] = field(default_factory=dict)
+    notes: tuple[str, ...] = ()
+
+    @property
+    def usd(self) -> float:
+        return float(self.fee)
+
+    @property
+    def trade_value(self) -> Decimal:
+        """C × p: what a buyer pays, or a seller receives, before fees."""
+        return self.contracts * self.price
+
+    @property
+    def fee_pct_of_trade_value(self) -> Decimal | None:
+        """Fee as a percentage of the trade value at this price (None when the value is 0)."""
+        value = self.trade_value
+        return None if value == 0 else self.fee / value * 100
+
+    @property
+    def cash_flow(self) -> Decimal:
+        """Signed cash for the trade including the fee: negative when you pay."""
+        return -(self.trade_value + self.fee) if self.side == "buy" else self.trade_value - self.fee
+
+    def breakdown(self) -> dict[str, str]:
+        """Plain strings, ready for JSON."""
+        pct = self.fee_pct_of_trade_value
+        out = {
+            "platform": self.platform_name,
+            "side": self.side,
+            "role": self.role,
+            "price": str(self.price),
+            "contracts": str(self.contracts),
+            "trade_value_usd": str(self.trade_value),
+            "coefficient": str(self.coefficient),
+            "raw_fee_usd": str(self.raw_fee),
+            "fee_usd": str(self.fee),
+            "fee_pct_of_trade_value": "" if pct is None else str(pct.quantize(Decimal("0.0001"))),
+            "cash_flow_usd": str(self.cash_flow),
+            "rounding": self.rounding,
+            "formula": self.formula,
+            "source_url": self.source_url,
+            "rates_as_of": self.rates_as_of,
+        }
+        out.update(self.details)
+        return out
+
+
+def _quadratic(coefficient: Decimal, contracts: Decimal, price: Decimal) -> Decimal:
+    return coefficient * contracts * price * (ONE - price)
+
+
+def _us_tier(rates: Rates, tier: int | str | None, volume_30d: Number | None) -> tuple[Decimal, str]:
+    us = rates.polymarket_us
+    if tier is not None and volume_30d is not None:
+        raise ValueError("give either tier or volume_30d, not both")
+    if volume_30d is not None:
+        vol = _num(volume_30d, "volume_30d")
+        if vol < 0:
+            raise ValueError("volume_30d must be >= 0")
+        for t in us.tiers:
+            if t.below is None or vol < t.below:
+                return t.theta, f"{t.label} (30-day taker volume ${vol:,})"
+    if tier is None:
+        first = us.tiers[0]
+        return first.theta, f"{first.label} (default: the highest coefficient)"
+    if isinstance(tier, str) and tier.strip().lower() in ("new", "new-account", "new_account"):
+        return us.new_account_theta, f"New account ({us.new_account_note})"
+    try:
+        n = int(str(tier).strip().lower().removeprefix("tier").removeprefix("t").strip())
+    except ValueError:
+        n = 0
+    for t in us.tiers:
+        if t.number == n:
+            return t.theta, t.label
+    valid = ", ".join([str(t.number) for t in us.tiers] + ["new"])
+    raise ValueError(f"unknown Polymarket US tier {tier!r}; use one of: {valid}")
+
+
+def _global_category(rates: Rates, category: str | None) -> tuple[str, Decimal]:
+    cats = rates.polymarket_global.rates
+    if category is None:
+        raise ValueError(f"polymarket.com needs a category; one of: {', '.join(cats)}")
+    for name, rate in cats.items():
+        if name.lower() == category.strip().lower():
+            return name, rate
+    raise ValueError(f"unknown polymarket.com category {category!r}; use one of: {', '.join(cats)}")
+
+
+def fee(
+    platform: str,
+    price: Number,
+    contracts: Number,
+    side: Side = "buy",
+    tier: int | str | None = None,
+    maker: bool = False,
+    *,
+    category: str | None = None,
+    multiplier: Number | None = None,
+    volume_30d: Number | None = None,
+    rates: Rates | None = None,
+) -> FeeResult:
+    """Trading fee for one order.
+
+    ``price`` is the price of the contract you trade, in dollars (0 < price < 1).
+    ``side`` only changes the cash flow; the fee formulas are symmetric.
+
+    Platform options:
+
+    * ``kalshi``: ``multiplier`` is the multiplier M. It defaults to 1 for takers
+      and 0 for makers (Kalshi charges makers only where the market says so, so pass
+      ``multiplier=1`` with ``maker=True`` for those). The fee is rounded up so that
+      fee + position cost (C × P) is a whole centicent ($0.0001).
+    * ``polymarket-us``: ``tier`` is 1-4 or ``"new"`` (first 7 days), or give
+      ``volume_30d`` (trailing 30-day taker volume in USD). Default: Tier 1.
+      Makers pay no fee.
+    * ``polymarket`` (polymarket.com): ``category`` is required. Makers pay no fee.
+    """
+    r = rates if rates is not None else default_rates()
+    key = platform_key(platform)
+    p = _num(price, "price")
+    c = _num(contracts, "contracts")
+    if not ONE > p > 0:
+        raise ValueError("price must be between 0 and 1 (exclusive), in dollars")
+    if c <= 0:
+        raise ValueError("contracts must be > 0")
+    if side not in ("buy", "sell"):
+        raise ValueError("side must be 'buy' or 'sell'")
+    if key != "polymarket-us" and (tier is not None or volume_30d is not None):
+        raise ValueError("tier and volume_30d only apply to polymarket-us")
+    if key != "kalshi" and multiplier is not None:
+        raise ValueError("multiplier only applies to kalshi")
+    if key != "polymarket" and category is not None:
+        raise ValueError("category only applies to polymarket (polymarket.com)")
+
+    role: Literal["taker", "maker"] = "maker" if maker else "taker"
+    details: dict[str, str] = {}
+    notes: list[str] = []
+    rounding: Rounding
+
+    if key == "kalshi":
+        k = r.kalshi
+        default_m = Decimal(0) if maker else ONE
+        m = default_m if multiplier is None else _num(multiplier, "multiplier")
+        if m not in k.multipliers:
+            allowed = ", ".join(str(x) for x in k.multipliers)
+            raise ValueError(f"unknown Kalshi series multiplier {m}; the rates file lists: {allowed}")
+        base = k.maker_rate if maker else k.taker_rate
+        coefficient = m * base
+        details["base_rate"] = str(base)
+        details["multiplier"] = str(m)
+        if k.version:
+            details["fee_schedule_version"] = k.version
+        if maker and multiplier is None:
+            notes.append(
+                "Kalshi maker multiplier defaults to 0; pass multiplier=1 for markets with maker fees."
+            )
+        rounding, formula, source, as_of = k.rounding, k.formula, k.source_url, k.as_of
+    elif key == "polymarket-us":
+        us = r.polymarket_us
+        theta, label = _us_tier(r, tier, volume_30d)
+        details["tier"] = label
+        details["theta"] = str(theta)
+        if maker:
+            coefficient = Decimal(0)
+            notes.append(f"Makers: {us.makers}. Maker rebates are not modelled.")
+        else:
+            coefficient = theta
+        rounding, formula, source, as_of = us.rounding, us.formula, us.source_url, us.as_of
+    else:
+        g = r.polymarket_global
+        cat, rate = _global_category(r, category)
+        details["category"] = cat
+        details["category_rate"] = str(rate)
+        if maker:
+            coefficient = Decimal(0)
+            notes.append("polymarket.com: makers are never charged fees.")
+        else:
+            coefficient = rate
+        notes.append(
+            "Each market's own feeSchedule is authoritative; series can differ from the category rate."
+        )
+        rounding, formula, source, as_of = g.rounding, g.formula, g.source_url, g.as_of
+
+    raw = _quadratic(coefficient, c, p)
+    # Kalshi (basis fee_plus_position_cost) rounds fee + C × P; the others round the fee alone.
+    rounded, rounding_text = rounding.apply(raw, c * p), rounding.describe()
+    return FeeResult(
+        platform=key,
+        platform_name=DISPLAY_NAMES[key],
+        side=side,
+        role=role,
+        price=p,
+        contracts=c,
+        coefficient=coefficient,
+        raw_fee=raw,
+        fee=rounded,
+        rounding=rounding_text,
+        formula=formula,
+        source_url=source,
+        rates_as_of=as_of or r.as_of,
+        details=details,
+        notes=tuple(notes),
+    )
+
+
+@dataclass(frozen=True)
+class BreakEven:
+    """The smallest price move that puts a round trip in profit after the fees on both orders."""
+
+    platform_name: str
+    side: Side
+    contracts: Decimal
+    entry_price: Decimal
+    entry_fee: Decimal
+    exit_price: Decimal | None
+    """First price on the tick grid where the round trip is > 0 after fees (None: none exists)."""
+    exit_fee: Decimal | None
+    move: Decimal | None
+    """exit_price − entry_price (positive for a buy, negative for a sell)."""
+    profit_at_exit: Decimal | None
+    tick: Decimal
+
+    @property
+    def move_cents(self) -> Decimal | None:
+        return None if self.move is None else self.move * 100
+
+
+def break_even(
+    platform: str,
+    price: Number,
+    contracts: Number,
+    side: Side = "buy",
+    tier: int | str | None = None,
+    maker: bool = False,
+    *,
+    tick: Number = "0.01",
+    category: str | None = None,
+    multiplier: Number | None = None,
+    volume_30d: Number | None = None,
+    rates: Rates | None = None,
+) -> BreakEven:
+    """How far the price must move before closing the position is in profit after fees.
+
+    Opens ``contracts`` at ``price`` (``side="buy"`` buys, ``"sell"`` sells) and closes
+    them at a later price on the ``tick`` grid, paying the fee on both orders with the
+    same role and options. Returns the first exit price where
+    proceeds − cost − entry fee − exit fee > 0.
+    """
+    r = rates if rates is not None else default_rates()
+    t = _num(tick, "tick")
+    if t <= 0:
+        raise ValueError("tick must be > 0")
+
+    def leg(at: Number, leg_side: Side) -> FeeResult:
+        return fee(
+            platform,
+            at,
+            contracts,
+            leg_side,
+            tier,
+            maker,
+            category=category,
+            multiplier=multiplier,
+            volume_30d=volume_30d,
+            rates=r,
+        )
+
+    entry = leg(price, side)
+    exit_side: Side = "sell" if side == "buy" else "buy"
+    step = t if side == "buy" else -t
+    q = entry.price + step
+    while ONE > q > 0:
+        ex = leg(q, exit_side)
+        profit = entry.cash_flow + ex.cash_flow
+        if profit > 0:
+            return BreakEven(
+                platform_name=entry.platform_name,
+                side=side,
+                contracts=entry.contracts,
+                entry_price=entry.price,
+                entry_fee=entry.fee,
+                exit_price=q,
+                exit_fee=ex.fee,
+                move=q - entry.price,
+                profit_at_exit=profit,
+                tick=t,
+            )
+        q += step
+    return BreakEven(
+        platform_name=entry.platform_name,
+        side=side,
+        contracts=entry.contracts,
+        entry_price=entry.price,
+        entry_fee=entry.fee,
+        exit_price=None,
+        exit_fee=None,
+        move=None,
+        profit_at_exit=None,
+        tick=t,
+    )

pmfees/data/prediction_market_fees.json

@@ -0,0 +1,101 @@
+{
+  "as_of": "2026-11-08",
+  "polymarket_global": {
+    "as_of": "2026-11-08",
+    "name": "Polymarket (international, polymarket.com)",
+    "source_url": "https://docs.polymarket.com/trading/fees",
+    "formula": "fee = C × feeRate × p × (1 − p); only takers pay; C = shares, p = share price",
+    "rates": {
+      "Crypto": 0.07,
+      "Sports": 0.05,
+      "Economics": 0.05,
+      "Culture": 0.05,
+      "Weather": 0.05,
+      "Other": 0.05,
+      "Combos": 0.05,
+      "Finance": 0.04,
+      "Politics": 0.04,
+      "Mentions": 0.04,
+      "Tech": 0.04,
+      "Geopolitics": 0.0
+    },
+    "rounding": {
+      "decimals": 5,
+      "mode": "half_up",
+      "note": "Fees are rounded to 5 decimals (minimum 0.00001 USDC)."
+    },
+    "maker_rebate_share": {
+      "Crypto": 0.2,
+      "Sports": 0.15,
+      "other fee-enabled categories": 0.25,
+      "Combos": 0.0
+    },
+    "notes": [
+      "Some series differ from the category rate (for example NFL and college football markets at 0.03 in November 2026); each market's feeSchedule is authoritative.",
+      "Fees apply only to markets created after their category's activation date; older markets can be fee-free."
+    ]
+  },
+  "polymarket_us": {
+    "as_of": "2026-11-09",
+    "name": "Polymarket US (CFTC-regulated app)",
+    "source_url": "https://docs.polymarket.us/fees",
+    "effective": "2026-11-06 13:00 ET",
+    "formula": "fee = Θ × C × p × (1 − p), one curve for all markets",
+    "taker_tiers_30d_volume_usd": [
+      {
+        "below": 10000,
+        "theta": 0.095
+      },
+      {
+        "below": 50000,
+        "theta": 0.085
+      },
+      {
+        "below": 250000,
+        "theta": 0.075
+      },
+      {
+        "below": null,
+        "theta": 0.0695
+      }
+    ],
+    "rounding": {
+      "decimals": 2,
+      "mode": "half_even",
+      "note": "Rounded to the nearest $0.01 with banker's rounding (half to even)."
+    },
+    "new_accounts": "Θ = 0.0695 for the first 7 days",
+    "makers": "no fee; maker rebates start from $10 million in maker volume",
+    "previous": "Θ = 0.0695 for all accounts (0.06 until 2026-09-17)",
+    "notes": [
+      "Combo taker fees (not modelled in the calculator): until 2026-11-11 13:00 ET fee = C × p × [0.0695 × (1 − p) + 0.085 × (1 − p)^4]; from 2026-11-11 13:00 ET fee = C × p × [Θ × (1 − p) + 0.06 × (1 − p)^4], with Θ the account's taker coefficient. Source: docs.polymarket.us/fees (announced as confirmed, seen 2026-11-09)."
+    ]
+  },
+  "kalshi": {
+    "as_of": "2026-11-10",
+    "name": "Kalshi",
+    "source_url": "https://kalshi.com/docs/kalshi-fee-schedule.pdf",
+    "source_date": "2026-07-07",
+    "version": "7.7.26",
+    "formula": "taker fee = round up(M × 0.07 × C × P × (1 − P)), M = 1 by default; maker fee = round up(M × 0.0175 × C × P × (1 − P)), M = 0 by default (only series listed with maker fees). Round up: fee + position cost (C × P) is rounded up to a whole centicent ($0.0001)",
+    "taker_rate": 0.07,
+    "maker_rate": 0.0175,
+    "multipliers": [
+      1,
+      0.5,
+      0
+    ],
+    "rounding": {
+      "decimals": 4,
+      "mode": "up",
+      "basis": "fee_plus_position_cost",
+      "source_url": "https://kalshi.com/docs/kalshi-fee-schedule.pdf",
+      "version": "7.7.26",
+      "note": "Kalshi rounds the fee up so that fee plus position cost (contracts × price) is a whole centicent ($0.0001), per the fee schedule (7.7.26, p. 2). Accounts cleared through a broker (FCM) keep balances in whole cents, so there the fee rounds to the cent.",
+      "broker_source_url": "https://docs.kalshi.com/getting_started/fee_rounding.md"
+    },
+    "notes": [
+      "M is a per-series multiplier (1, 0.5 or 0); default 1 for taker fees, 0 for maker fees."
+    ]
+  }
+}

pmfees/rates.py

@@ -0,0 +1,265 @@
+"""Load fee rates from ``prediction_market_fees.json``.
+
+The JSON file is the only place rates, tiers, multipliers and rounding rules live.
+Nothing in this package hardcodes a rate: pass ``path=`` (or set ``PMFEES_RATES_FILE``)
+to use an updated file without a new release.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from decimal import ROUND_HALF_EVEN, ROUND_HALF_UP, ROUND_UP, Decimal
+from importlib import resources
+from pathlib import Path
+from typing import Any
+
+ENV_VAR = "PMFEES_RATES_FILE"
+
+_ROUNDING_MODES = {"up": ROUND_UP, "half_even": ROUND_HALF_EVEN, "half_up": ROUND_HALF_UP}
+_ROUNDING_WORDS = {
+    "up": "rounded up",
+    "half_even": "rounded half to even (banker's rounding)",
+    "half_up": "rounded half up",
+}
+
+
+class RatesError(ValueError):
+    """The rates file is missing a field or has a value the package cannot use."""
+
+
+BASES = (None, "fee_plus_position_cost")
+
+
+@dataclass(frozen=True)
+class Rounding:
+    decimals: int
+    mode: str
+    note: str
+    basis: str | None = None
+    """``fee_plus_position_cost`` (Kalshi): fee + position cost (C × P) is rounded, not the fee alone."""
+
+    def apply(self, value: Decimal, position_cost: Decimal = Decimal(0)) -> Decimal:
+        q = Decimal(1).scaleb(-self.decimals)
+        if self.basis == "fee_plus_position_cost":
+            return (position_cost + value).quantize(q, rounding=_ROUNDING_MODES[self.mode]) - position_cost
+        return value.quantize(q, rounding=_ROUNDING_MODES[self.mode])
+
+    def describe(self) -> str:
+        unit = {2: "the cent", 4: "a whole centicent ($0.0001)"}.get(
+            self.decimals, f"{self.decimals} decimals"
+        )
+        if self.basis == "fee_plus_position_cost":
+            return f"{_ROUNDING_WORDS[self.mode]} so that fee + position cost is {unit}"
+        return f"{_ROUNDING_WORDS[self.mode]} to {unit}"
+
+
+@dataclass(frozen=True)
+class UsTier:
+    number: int
+    below: Decimal | None
+    theta: Decimal
+
+    @property
+    def label(self) -> str:
+        return f"Tier {self.number}"
+
+
+@dataclass(frozen=True)
+class PolymarketGlobal:
+    name: str
+    source_url: str
+    formula: str
+    rates: dict[str, Decimal]
+    rounding: Rounding
+    maker_rebate_share: dict[str, Decimal]
+    notes: tuple[str, ...]
+    as_of: str = ""
+    """Date these rates were last checked against ``source_url``."""
+
+
+@dataclass(frozen=True)
+class PolymarketUS:
+    name: str
+    source_url: str
+    effective: str
+    formula: str
+    tiers: tuple[UsTier, ...]
+    new_account_theta: Decimal
+    new_account_note: str
+    makers: str
+    rounding: Rounding
+    notes: tuple[str, ...]
+    as_of: str = ""
+    """Date these rates were last checked against ``source_url``."""
+
+
+@dataclass(frozen=True)
+class Kalshi:
+    name: str
+    source_url: str
+    source_date: str
+    formula: str
+    taker_rate: Decimal
+    maker_rate: Decimal
+    multipliers: tuple[Decimal, ...]
+    rounding: Rounding
+    rounding_source_url: str | None
+    notes: tuple[str, ...]
+    as_of: str = ""
+    """Date these rates were last checked against ``source_url``."""
+    version: str = ""
+    """Version of the Kalshi fee schedule the rates come from (for example ``7.7.26``)."""
+
+
+@dataclass(frozen=True)
+class Rates:
+    as_of: str
+    path: str
+    polymarket_global: PolymarketGlobal
+    polymarket_us: PolymarketUS
+    kalshi: Kalshi
+
+
+def _get(obj: dict[str, Any], key: str, where: str) -> Any:
+    if key not in obj:
+        raise RatesError(f"{where}: missing field {key!r}")
+    return obj[key]
+
+
+def _dec(value: Any, where: str) -> Decimal:
+    if isinstance(value, bool) or not isinstance(value, (Decimal, int)):
+        raise RatesError(f"{where}: expected a number, got {value!r}")
+    d = Decimal(value)
+    if d < 0:
+        raise RatesError(f"{where}: negative value {value!r}")
+    return d
+
+
+def _rounding(obj: dict[str, Any], where: str) -> Rounding:
+    mode = _get(obj, "mode", where)
+    if mode not in _ROUNDING_MODES:
+        raise RatesError(f"{where}: unknown rounding mode {mode!r}")
+    decimals = _get(obj, "decimals", where)
+    if not isinstance(decimals, int) or decimals < 0:
+        raise RatesError(f"{where}: decimals must be a non-negative integer")
+    basis = obj.get("basis")
+    if basis not in BASES:
+        raise RatesError(f"{where}: unknown rounding basis {basis!r}")
+    return Rounding(decimals=decimals, mode=mode, note=str(obj.get("note", "")), basis=basis)
+
+
+def _new_account_theta(text: str, where: str) -> Decimal:
+    # The file states it as text, e.g. "Θ = 0.0695 for the first 7 days".
+    for token in text.replace("=", " ").split():
+        try:
+            return _dec(Decimal(token), where)
+        except ArithmeticError:
+            continue
+    raise RatesError(f"{where}: no coefficient found in {text!r}")
+
+
+def parse_rates(data: dict[str, Any], path: str = "<memory>") -> Rates:
+    """Build :class:`Rates` from the decoded JSON (numbers decoded as ``Decimal``)."""
+    g = _get(data, "polymarket_global", "root")
+    us = _get(data, "polymarket_us", "root")
+    k = _get(data, "kalshi", "root")
+
+    tiers: list[UsTier] = []
+    raw_tiers = _get(us, "taker_tiers_30d_volume_usd", "polymarket_us")
+    for i, t in enumerate(raw_tiers, start=1):
+        where = f"polymarket_us.taker_tiers_30d_volume_usd[{i - 1}]"
+        below = _get(t, "below", where)
+        tiers.append(
+            UsTier(
+                number=i,
+                below=None if below is None else _dec(below, where),
+                theta=_dec(_get(t, "theta", where), where),
+            )
+        )
+    if not tiers or tiers[-1].below is not None:
+        raise RatesError("polymarket_us: the last tier must have below = null")
+
+    new_accounts = str(_get(us, "new_accounts", "polymarket_us"))
+    rounding_k = _get(k, "rounding", "kalshi")
+    as_of = str(_get(data, "as_of", "root"))
+
+    return Rates(
+        as_of=as_of,
+        path=path,
+        polymarket_global=PolymarketGlobal(
+            name=str(_get(g, "name", "polymarket_global")),
+            source_url=str(_get(g, "source_url", "polymarket_global")),
+            formula=str(_get(g, "formula", "polymarket_global")),
+            rates={
+                cat: _dec(r, f"polymarket_global.rates.{cat}")
+                for cat, r in _get(g, "rates", "polymarket_global").items()
+            },
+            rounding=_rounding(_get(g, "rounding", "polymarket_global"), "polymarket_global.rounding"),
+            maker_rebate_share={
+                cat: _dec(r, f"polymarket_global.maker_rebate_share.{cat}")
+                for cat, r in g.get("maker_rebate_share", {}).items()
+            },
+            notes=tuple(g.get("notes", ())),
+            as_of=str(g.get("as_of") or as_of),
+        ),
+        polymarket_us=PolymarketUS(
+            name=str(_get(us, "name", "polymarket_us")),
+            source_url=str(_get(us, "source_url", "polymarket_us")),
+            effective=str(us.get("effective", "")),
+            formula=str(_get(us, "formula", "polymarket_us")),
+            tiers=tuple(tiers),
+            new_account_theta=_new_account_theta(new_accounts, "polymarket_us.new_accounts"),
+            new_account_note=new_accounts,
+            makers=str(us.get("makers", "")),
+            rounding=_rounding(_get(us, "rounding", "polymarket_us"), "polymarket_us.rounding"),
+            notes=tuple(us.get("notes", ())),
+            as_of=str(us.get("as_of") or as_of),
+        ),
+        kalshi=Kalshi(
+            name=str(_get(k, "name", "kalshi")),
+            source_url=str(_get(k, "source_url", "kalshi")),
+            source_date=str(k.get("source_date", "")),
+            formula=str(_get(k, "formula", "kalshi")),
+            taker_rate=_dec(_get(k, "taker_rate", "kalshi"), "kalshi.taker_rate"),
+            maker_rate=_dec(_get(k, "maker_rate", "kalshi"), "kalshi.maker_rate"),
+            multipliers=tuple(_dec(m, "kalshi.multipliers") for m in _get(k, "multipliers", "kalshi")),
+            rounding=_rounding(rounding_k, "kalshi.rounding"),
+            rounding_source_url=rounding_k.get("source_url"),
+            notes=tuple(k.get("notes", ())),
+            as_of=str(k.get("as_of") or as_of),
+            version=str(k.get("version", "")),
+        ),
+    )
+
+
+def load_rates(path: str | os.PathLike[str] | None = None) -> Rates:
+    """Load rates from ``path``, else ``$PMFEES_RATES_FILE``, else the bundled file."""
+    chosen = path if path is not None else os.environ.get(ENV_VAR) or None
+    if chosen is not None:
+        p = Path(chosen)
+        text = p.read_text(encoding="utf-8")
+        label = str(p)
+    else:
+        res = resources.files("pmfees").joinpath("data/prediction_market_fees.json")
+        text = res.read_text(encoding="utf-8")
+        label = "bundled prediction_market_fees.json"
+    try:
+        data = json.loads(text, parse_float=Decimal)
+    except json.JSONDecodeError as exc:
+        raise RatesError(f"{label}: not valid JSON ({exc})") from exc
+    if not isinstance(data, dict):
+        raise RatesError(f"{label}: expected a JSON object")
+    return parse_rates(data, label)
+
+
+_default: Rates | None = None
+
+
+def default_rates() -> Rates:
+    """The rates used when no ``rates=`` argument is given (loaded once)."""
+    global _default
+    if _default is None:
+        _default = load_rates()
+    return _default

pmfees-0.1.0.dist-info/METADATA

@@ -0,0 +1,232 @@
+Metadata-Version: 2.4
+Name: pmfees
+Version: 0.1.0
+Summary: Exact trading fees for Kalshi, Polymarket US and polymarket.com, with a CLI and break-even helper.
+Author-email: SwapHunt <github@swaphunt.dev>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/swaphunt/pmfees
+Project-URL: Source, https://github.com/swaphunt/pmfees
+Project-URL: Issues, https://github.com/swaphunt/pmfees/issues
+Project-URL: Changelog, https://github.com/swaphunt/pmfees/blob/main/CHANGELOG.md
+Project-URL: Fee calculator, https://swaphunt.dev/tools/kalshi-vs-polymarket-fee-calculator
+Keywords: kalshi,polymarket,prediction markets,fees,trading
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Classifier: Development Status :: 4 - Beta
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pmfees
+
+Exact trading fees for the prediction market platforms **Kalshi**, **Polymarket US** and
+**polymarket.com** (international), as a small Python library and a command line tool.
+
+- The platforms' own formulas and rounding rules: Kalshi rounds up so that fee + position cost
+  is a whole centicent ($0.0001), Polymarket US rounds to the cent with banker's rounding,
+  polymarket.com rounds to 5 decimals.
+- Exact decimal arithmetic (`decimal.Decimal`), so $1.75 is $1.75 and not $1.7500000000000002.
+- A break-even helper: how far the price has to move before a round trip is in profit after
+  the fee on both orders.
+- No dependencies outside the Python standard library. Typed (`py.typed`).
+
+Rates current as of: Kalshi 2026-11-10 (fee schedule 7.7.26), Polymarket US 2026-11-09,
+polymarket.com 2026-11-08. Each platform's date and source are in the rates file and in every result.
+
+Other ways to get the same numbers, from the same rates file:
+
+- In a browser: the [SwapHunt Kalshi vs Polymarket fee calculator](https://swaphunt.dev/tools/kalshi-vs-polymarket-fee-calculator).
+- Over HTTP, for agents: [`GET https://x402.swaphunt.dev/v1/pm/fees`](https://swaphunt.dev/api), paid per call
+  with [x402](https://www.x402.org/) in USDC. This package is free; the endpoint exists for agents that
+  cannot install a library.
+
+## Install
+
+```bash
+pip install pmfees
+```
+
+Python 3.10 or newer.
+
+## Command line
+
+```bash
+pmfees kalshi --price 0.50 --contracts 100
+```
+
+```text
+Kalshi taker fee: $1.75 (3.50% of trade value at 50¢)
+  buy 100 contracts at $0.50 = $50.00 trade value
+  base rate: 0.07
+  multiplier: 1
+  fee schedule version: 7.7.26
+  0.07 × 100 × 0.5 × (1 − 0.5) = 1.75, rounded up so that fee + position cost is a whole centicent ($0.0001): $1.75
+  rates as of 2026-11-10 · source: https://kalshi.com/docs/kalshi-fee-schedule.pdf
+```
+
+More examples:
+
+```bash
+# Polymarket US, Tier 1 (under $10,000 of 30-day taker volume, the default)
+pmfees polymarket-us --price 0.50 --contracts 100
+# -> Polymarket US taker fee: $2.38 (4.76% of trade value at 50¢)   [0.095 × 100 × 0.5 × 0.5 = 2.375]
+
+# polymarket.com, Crypto category
+pmfees polymarket --price 0.25 --contracts 100 --category Crypto
+# -> polymarket.com taker fee: $1.3125 (5.25% of trade value at 25¢)
+
+# Break-even: buy 100 on Kalshi at 50¢, when is selling in profit?
+pmfees kalshi --price 0.50 --contracts 100 --break-even
+# -> Break-even: the price must rise 4¢ to 54¢ (tick 1¢); entry fee $1.75 + exit fee $1.7388, profit at that price $0.5112
+```
+
+Options:
+
+| Option | Platforms | Meaning |
+|---|---|---|
+| `--price` | all | Price of the contract you trade, in dollars (0 < price < 1) |
+| `--contracts` | all | Number of contracts (shares on polymarket.com) |
+| `--side buy\|sell` | all | Changes the cash flow only; the fee formulas are symmetric |
+| `--maker` | all | Maker order. Kalshi: maker rate 0.0175 with M default 0, so pass `--multiplier 1` on markets with maker fees. Polymarket US and polymarket.com: makers pay no fee |
+| `--multiplier` | kalshi | Fee multiplier M (default 1 for takers, 0 for makers) |
+| `--tier 1-4\|new` | polymarket-us | Taker tier, or `new` for the first 7 days of a new account (default 1) |
+| `--volume` | polymarket-us | Trailing 30-day taker volume in USD; picks the tier for you |
+| `--category` | polymarket | Market category, e.g. `Crypto`, `Sports`, `Politics` (required) |
+| `--break-even`, `--tick` | all | Also print the break-even move (price step, default 0.01) |
+| `--json` | all | Machine-readable output |
+| `--rates PATH` | all | Use an updated rates file |
+
+`pmfees rates` prints the loaded rates and their date.
+
+## Library
+
+```python
+from pmfees import fee, break_even
+
+r = fee("kalshi", 0.50, 100)
+r.fee  # Decimal('1.7500')  what you pay, in USD
+r.raw_fee  # Decimal('1.7500') before rounding
+r.fee_pct_of_trade_value  # Decimal('3.500')
+r.breakdown()  # dict of strings: coefficient, rounding, formula, source_url, rates_as_of, ...
+
+fee("polymarket-us", 0.10, 1000, "buy", tier=4).fee  # Decimal('6.26')
+fee("polymarket-us", 0.10, 1000, volume_30d=12_500).fee  # Tier 2
+fee("polymarket", 0.25, 100, category="Crypto").fee  # Decimal('1.31250')
+fee("kalshi", 0.50, 1).fee  # Decimal('0.0175')  centicent rounding, not $0.02
+fee("kalshi", 0.50, 100, maker=True).fee  # Decimal('0.0000')  maker M defaults to 0
+fee("kalshi", 0.50, 100, maker=True, multiplier=1).fee  # Decimal('0.4375')
+fee("kalshi", 0.50, 100, multiplier=0.5).fee  # Decimal('0.8750')
+
+b = break_even("polymarket-us", 0.40, 500, tier=2)
+b.exit_price, b.move_cents  # (Decimal('0.45'), Decimal('5.00'))
+```
+
+Signature: `fee(platform, price, contracts, side="buy", tier=None, maker=False, *, category=None,
+multiplier=None, volume_30d=None, rates=None) -> FeeResult`. Platform names: `kalshi`,
+`polymarket-us`, `polymarket` (also `polymarket.com`). Prices and counts can be `str`, `int`,
+`float` or `Decimal`; floats are converted through `str`, so `0.1` means exactly 0.1.
+
+`break_even(...)` takes the same arguments plus `tick`. It opens the position at `price`, then
+walks the price in `tick` steps (up for a buy, down for a sell) and returns the first exit price
+where proceeds − cost − entry fee − exit fee > 0, or `exit_price=None` if no price before $1 (or
+$0) works.
+
+## Kalshi: centicent rounding and the multiplier
+
+Kalshi does not round the fee on its own. It rounds **fee + position cost** (contracts × price) up to
+a whole centicent ($0.0001), per the fee schedule (version 7.7.26, page 2). Most of the time that
+looks like rounding the fee up to four decimals, but the fee alone is what you see change:
+
+```python
+from pmfees import fee
+
+fee("kalshi", 0.50, 1).fee  # Decimal('0.0175')  0.07 × 1 × 0.5 × 0.5 = 0.0175 exactly; not $0.02
+fee("kalshi", 0.33, 7).fee  # Decimal('0.1084')  raw 0.108339; 2.31 + 0.108339 = 2.418339 -> 2.4184
+```
+
+Accounts cleared through a broker (FCM) keep balances in whole cents, so there the fee rounds to the
+cent ([Kalshi docs](https://docs.kalshi.com/getting_started/fee_rounding.md)). pmfees models
+kalshi.com accounts (direct members).
+
+Each Kalshi series has a fee multiplier M: 1 (standard), 0.5 or 0. Takers default to M = 1, makers
+to M = 0, because Kalshi charges makers only on series listed with maker fees:
+
+```python
+fee("kalshi", 0.25, 100).fee  # Decimal('1.3125')  M = 1
+fee("kalshi", 0.25, 100, multiplier=0.5).fee  # Decimal('0.6563')  raw 0.65625, rounded up
+fee("kalshi", 0.50, 100, maker=True).fee  # Decimal('0.0000')  maker, M defaults to 0
+fee("kalshi", 0.50, 100, maker=True, multiplier=1).fee  # Decimal('0.4375')  0.0175 × 100 × 0.25
+```
+
+```bash
+pmfees kalshi --price 0.25 --contracts 100 --multiplier 0.5
+# -> Kalshi taker fee: $0.6563 (2.63% of trade value at 25¢)
+```
+
+## The formulas
+
+| Platform | Taker fee | Rounding |
+|---|---|---|
+| Kalshi | M × 0.07 × C × P × (1 − P), M default 1; maker M × 0.0175 × C × P × (1 − P), M default 0 | Up, so that fee + position cost is a whole centicent ($0.0001) |
+| Polymarket US | Θ × C × p × (1 − p), Θ by 30-day taker volume: 0.095 (< $10K), 0.085 (< $50K), 0.075 (< $250K), 0.0695 ($250K+); new accounts 0.0695 for the first 7 days | Nearest cent, half to even |
+| polymarket.com | C × rate × p × (1 − p), rate by category (Crypto 0.07; Sports, Economics, Culture, Weather, Other, Combos 0.05; Finance, Politics, Mentions, Tech 0.04; Geopolitics 0) | 5 decimals |
+
+The numbers in this table are for reading only. The code takes every rate, tier, multiplier and
+rounding rule (including Kalshi's fee + position cost basis) from `prediction_market_fees.json`.
+
+Not modelled: Polymarket US combo fees and maker rebates, polymarket.com maker and taker rebate
+programs, and per-market exceptions (polymarket.com
+markets carry their own `feeSchedule`, Kalshi series their own multiplier). Check the market when
+it matters.
+
+## Sources
+
+| Platform | Source | Rates current as of |
+|---|---|---|
+| Kalshi | <https://kalshi.com/docs/kalshi-fee-schedule.pdf> (version 7.7.26) | 2026-11-10 |
+| Polymarket US | <https://docs.polymarket.us/fees> | 2026-11-09 |
+| polymarket.com | <https://docs.polymarket.com/trading/fees> | 2026-11-08 |
+
+The tests lock the formulas to the worked examples and fee tables on these pages, with a link
+to the source in each test.
+
+## Updating the rates
+
+All rates live in `src/pmfees/data/prediction_market_fees.json`. Each platform has its own `as_of`
+(the date its rates were last checked against `source_url`). SwapHunt checks the official fee pages
+every week; when a rate changes, the updated file arrives here as a pull request, and a new release
+follows after review. To use newer rates without waiting for a release:
+
+```python
+from pmfees import fee, load_rates
+
+rates = load_rates("prediction_market_fees.json")
+fee("kalshi", 0.50, 100, rates=rates)
+```
+
+or set `PMFEES_RATES_FILE=/path/to/prediction_market_fees.json`, or pass `--rates` on the
+command line. A file with a missing field or an unknown rounding mode is rejected with a
+`RatesError` that names the field.
+
+## Development
+
+```bash
+pip install -e . pytest ruff mypy
+pytest
+ruff check . && ruff format --check .
+mypy
+```
+
+Releases go to PyPI from GitHub Actions with trusted publishing: bump `__version__`, add a
+CHANGELOG entry, and push a `v<version>` tag. The publish job waits for approval.
+
+## Disclaimer
+
+Fee estimates for information only. The platform's own confirmation is what you pay.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

pmfees-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+pmfees/__init__.py,sha256=I897uC5YPdAsjPeH91a9eFlZkkh7DwQznW9Z2zicNrE,659
+pmfees/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+pmfees/cli.py,sha256=TkAhS6KvRm7NKbyZ0n4Zg2_S4ylKSiPqfWH7m6Chi5A,7482
+pmfees/core.py,sha256=uUPWjXAeg7_m5Wv_Haug-a31udtAnBL1RpWf2A7k9Xs,13258
+pmfees/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pmfees/rates.py,sha256=FuaPKmqN8JUIMxnG0bTvQVHCG0ZvBIxwV7zN-l4zv0M,9338
+pmfees/data/prediction_market_fees.json,sha256=4cGczSPTImETD_2pF7RUSFifEr1azZ4YF327wmgq8lE,3757
+pmfees-0.1.0.dist-info/licenses/LICENSE,sha256=T-Ys1tHHacpFh5TuhSsZ_4qsGuZasUG5I_RMUG6PK-k,1065
+pmfees-0.1.0.dist-info/METADATA,sha256=dfvX67_NII5EJtoG4X9dbtizDxWAedgRs7pcUpgNoy4,10463
+pmfees-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+pmfees-0.1.0.dist-info/entry_points.txt,sha256=sugxa34guA5WlSdLmAXmXaY_AtAm73i0tskaSLmI5DM,43
+pmfees-0.1.0.dist-info/top_level.txt,sha256=f8789C1LmCwDMPY8onCj6bSk0oHTIpLr6q-1Iyh7UKw,7
+pmfees-0.1.0.dist-info/RECORD,,

pmfees-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pmfees-0.1.0.dist-info/entry_points.txt

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

pmfees-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SwapHunt
+
+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.

pmfees-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pmfees