backtest-audit-kit 0.1.0__tar.gz

backtest_audit_kit-0.1.0/LICENSE

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

backtest_audit_kit-0.1.0/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: backtest-audit-kit
+Version: 0.1.0
+Summary: Audit a backtest: look-ahead lint, ledger invariants, mutation coverage, cost checks. Pure standard library.
+Author: rytjy
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rytjy/backtest-audit-kit
+Project-URL: Repository, https://github.com/rytjy/backtest-audit-kit
+Keywords: backtesting,lookahead-bias,audit,trading,quant,mutation-testing,invariants,backtest-overfitting
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# backtest-audit-kit
+
+**"I verify whether your strategy is real — or whether the backtest lied to you."**
+
+A tiny, dependency-free toolkit that audits a backtest the way an accountant
+audits a ledger and a QA engineer audits a test suite. It does not sell you
+returns; it finds the four ways a backtest most often lies.
+
+> **回测审计 / 策略代码复核服务** — 一页说明与联系方式 → **[PORTFOLIO.md](PORTFOLIO.md)**
+> **Backtest audits · strategy-code review** — one-page overview → **[PORTFOLIO.md](PORTFOLIO.md)**
+
+---
+
+## English
+
+**What it is.** A pure standard-library (Python 3.9+) kit of four independent
+checkers for a trading backtest:
+
+| Checker | Question it answers |
+|---|---|
+| `checks/lookahead.py` | Does any decision on bar `i` see bars `i+1...`? (AST-based future-function lint) |
+| `checks/invariants.py` | Does the ledger obey accounting invariants? (equity identity, `wd_cum` carry, monotonic counters, non-negative balances) |
+| `checks/mutants.py` | Which bugs would your test suite *not* catch? (mutation testing; survivors = coverage blind spots) |
+| `checks/fees.py` | Are fees two-sided, funding charged per bar, and slippage counted once per fill? |
+
+**Who it is for.** Quant developers, prop-desk researchers, and anyone who has
+ever shipped a strategy that looked great in a notebook and died in
+production. If you are reviewing someone else's backtest — or your own — this
+gives you a checklist, reproduction scripts, and before/after numbers instead
+of opinions.
+
+**What I deliver.** ① A ranked findings list plus a runnable reproduction
+script for each problem. ② A minimal fix patch. ③ A before/after reconciliation
+of the headline numbers (win rate, net PnL, multiple, MDD, t-stat).
+
+**Sample cases** (full write-ups in `cases/`):
+
+1. **Look-ahead** — the exit scan ran on the entry bar, so every signal knew
+   its outcome. Fixed: 91 trades / 90.1% / **+$214.37** → 26 trades / 65.4% /
+   **-$0.12**; a tick-level re-run gives 27 trades / 66.7% / **+$0.37**. The
+   leak was worth **≈ $214** of imaginary PnL — the whole profit.
+2. **Withdrawal accounting** — the bust path dropped `wd_cum`, so any strategy
+   with withdrawals was systematically understated. Fixed: same 2024–26 config
+   **7.82x → 215.27x** (a ≈ 27x gap; withdrawal rules "double-keep-half" vs
+   "double-keep-100" differ by ~27x).
+3. **Drawdown metric** — the circuit-breaker reset the running peak, so the
+   "reported MDD" was only the local drawdown. Investor-view raw drawdown
+   **99.7%** vs reported **53.1%** — a **46 pp** gap. Conclusion: MDD must be
+   written twice (breaker-local *and* raw).
+   (*Bonus case 4:* 5-minute bar clustering inflated `n` ~11x and turned
+   t = 15.60 into t = 1.75 after a 24h cooldown.)
+4. **Cost omission** (`cases/case5_cost_omission.md`) — a high-turnover 50x
+   book charged **no** fee, funding or slippage; its take-profit needed only a
+   **+0.08%** move while one round trip costs **0.09%** (the venue's real 4.5 bps
+   taker), so the target sat below the toll and every win is a net loss. At the
+   venue rate the omitted cost ran **~5.4x the starting capital** and **~17.8x the
+   reported profit**.
+
+**Install.**
+
+```bash
+pip install backtest-audit-kit
+```
+
+**Use it in code** (four checkers, pure standard library):
+
+```python
+from auditkit.checks import lookahead
+findings = lookahead.detect_file("strategy.py")   # future-data lint
+print(lookahead.format_findings(findings))
+```
+
+**How to run.**
+
+```bash
+cd portfolio/backtest-audit-kit
+python3 -m unittest discover tests      # stdlib only, no install
+# or, if you have pytest:
+python3 -m pytest tests/ -q
+python3 examples/run_demo.py            # see all four checkers in action
+```
+
+**Honesty note.** The look-ahead checker is a heuristic linter, not a proof
+engine: it flags the *shapes* that leak, and a stand-alone forward-simulation
+pass is reported `MEDIUM` for human review rather than being declared safe.
+Mutation testing reports blind spots; it never claims your strategy is
+profitable. No checker here predicts returns.
+
+---
+
+## 中文
+
+**是什么。** 一个纯 Python 标准库（3.9+）实现的回测审计工具包，四个互相独立
+的检查器：
+
+| 检查器 | 回答的问题 |
+|---|---|
+| `checks/lookahead.py` | 在 bar `i` 上的决策，是否读到了 `i+1...` 的数据？（基于 AST 的前视/未来函数检测） |
+| `checks/invariants.py` | 账本是否满足会计不变量？（权益恒等式、`wd_cum` 结转、计数器单调、余额非负） |
+| `checks/mutants.py` | 你的测试套件**抓不到**哪些 bug？（变异测试；存活的变异体 = 覆盖盲区） |
+| `checks/fees.py` | 手续费是否双边计、资金费是否逐 bar 计、滑点是否每笔只算一次？ |
+
+**给谁用。** 量化开发者、自营研究岗、以及任何"回测很美、实盘就死"过的
+人。带看别人的回测（或自己的）时，它给你的是**问题清单 + 复现脚本 + 修复前后
+的数字**，而不是一句"我觉得不太行"。
+
+**交付物承诺。** ① 按严重度排序的问题清单，每个问题配一个可运行的复现脚本。
+② 最小修复补丁。③ 修复前后的对账数字（胜率 / 净利 / 倍数 / 回撤 / t 值）。
+
+**案例摘要**（完整写在 `cases/`）：
+
+1. **前视 bug** —— 出场扫描写在开仓 bar 的循环内，每个信号都提前知道结果。
+   修复后：91 笔 / 90.1% / **+$214.37** → 26 笔 / 65.4% / **-$0.12**；tick 级
+   复跑得 27 笔 / 66.7% / **+$0.37**。这个泄漏值 **约 $214 的虚假收益**，
+   即全部利润。
+2. **提现会计 bug** —— 爆仓返程丢了 `wd_cum`，导致所有带提现的策略历史收益被
+   系统性低估。修复后：同一配置 2024–26 **7.82x → 215.27x**（相差约 27 倍；
+   提现规则"翻 2 留 1"与"翻 200 留 100"之间也差约 27 倍）。
+3. **回撤口径 bug** —— 熔断触发时把 peak 重置为 cap，"报告 MDD"只是每段熔断
+   后的局部回撤。投资者口径的原始回撤 **99.7%** vs 报告 **53.1%**，**差 46
+   个百分点**。结论：MDD 必须双写（熔断口径 + 原始口径）。
+   （**附赠案例 4**：一段暴跌连打十几根 5min bar 让样本量虚增约 11 倍，t 值从
+   15.60 在 24h 冷却去重后掉到 1.75。）
+4. **成本漏算**（`cases/case5_cost_omission.md`）—— 一个高换手 50x 账本**完全没算**手续费/资金费/滑点；止盈只需价格动 **+0.08%**，而一趟往返 **0.09%**（场馆真实 4.5bps taker）⇒ 目标在成本之下，每笔赢单净亏。按场馆真实费率，漏掉的成本约 **5.4× 本金**、**17.8× 账面收益**。
+
+**怎么跑。**
+
+```bash
+cd portfolio/backtest-audit-kit
+python3 -m unittest discover tests      # 只用标准库，无需安装
+# 若装了 pytest：
+python3 -m pytest tests/ -q
+python3 examples/run_demo.py            # 四个检查器全跑一遍
+```
+
+**诚实声明。** 前视检查器是启发式 linter，不是证明器：它抓的是会泄漏的**代码
+形态**，独立的"向前模拟"循环会被标为 `MEDIUM` 交人工复核，而不是被判安全。
+变异测试只报告覆盖盲区，从不声称你的策略赚钱。本工具包不预测任何收益。
+
+---
+
+## Also in this account · 另见
+
+- [`outpost/`](./outpost/) — 一个"只放能跑、能查、能被否证的东西"的据点：
+  单文件表格整理工具（零依赖、离线自检 14 项）+ 一份**被自己推翻**的回测（做空山寨无 edge）
+  + 一次"两条腿都断了"的数据源修复。不写客户名、不写"我能做什么"。

backtest_audit_kit-0.1.0/README.md

@@ -0,0 +1,146 @@
+# backtest-audit-kit
+
+**"I verify whether your strategy is real — or whether the backtest lied to you."**
+
+A tiny, dependency-free toolkit that audits a backtest the way an accountant
+audits a ledger and a QA engineer audits a test suite. It does not sell you
+returns; it finds the four ways a backtest most often lies.
+
+> **回测审计 / 策略代码复核服务** — 一页说明与联系方式 → **[PORTFOLIO.md](PORTFOLIO.md)**
+> **Backtest audits · strategy-code review** — one-page overview → **[PORTFOLIO.md](PORTFOLIO.md)**
+
+---
+
+## English
+
+**What it is.** A pure standard-library (Python 3.9+) kit of four independent
+checkers for a trading backtest:
+
+| Checker | Question it answers |
+|---|---|
+| `checks/lookahead.py` | Does any decision on bar `i` see bars `i+1...`? (AST-based future-function lint) |
+| `checks/invariants.py` | Does the ledger obey accounting invariants? (equity identity, `wd_cum` carry, monotonic counters, non-negative balances) |
+| `checks/mutants.py` | Which bugs would your test suite *not* catch? (mutation testing; survivors = coverage blind spots) |
+| `checks/fees.py` | Are fees two-sided, funding charged per bar, and slippage counted once per fill? |
+
+**Who it is for.** Quant developers, prop-desk researchers, and anyone who has
+ever shipped a strategy that looked great in a notebook and died in
+production. If you are reviewing someone else's backtest — or your own — this
+gives you a checklist, reproduction scripts, and before/after numbers instead
+of opinions.
+
+**What I deliver.** ① A ranked findings list plus a runnable reproduction
+script for each problem. ② A minimal fix patch. ③ A before/after reconciliation
+of the headline numbers (win rate, net PnL, multiple, MDD, t-stat).
+
+**Sample cases** (full write-ups in `cases/`):
+
+1. **Look-ahead** — the exit scan ran on the entry bar, so every signal knew
+   its outcome. Fixed: 91 trades / 90.1% / **+$214.37** → 26 trades / 65.4% /
+   **-$0.12**; a tick-level re-run gives 27 trades / 66.7% / **+$0.37**. The
+   leak was worth **≈ $214** of imaginary PnL — the whole profit.
+2. **Withdrawal accounting** — the bust path dropped `wd_cum`, so any strategy
+   with withdrawals was systematically understated. Fixed: same 2024–26 config
+   **7.82x → 215.27x** (a ≈ 27x gap; withdrawal rules "double-keep-half" vs
+   "double-keep-100" differ by ~27x).
+3. **Drawdown metric** — the circuit-breaker reset the running peak, so the
+   "reported MDD" was only the local drawdown. Investor-view raw drawdown
+   **99.7%** vs reported **53.1%** — a **46 pp** gap. Conclusion: MDD must be
+   written twice (breaker-local *and* raw).
+   (*Bonus case 4:* 5-minute bar clustering inflated `n` ~11x and turned
+   t = 15.60 into t = 1.75 after a 24h cooldown.)
+4. **Cost omission** (`cases/case5_cost_omission.md`) — a high-turnover 50x
+   book charged **no** fee, funding or slippage; its take-profit needed only a
+   **+0.08%** move while one round trip costs **0.09%** (the venue's real 4.5 bps
+   taker), so the target sat below the toll and every win is a net loss. At the
+   venue rate the omitted cost ran **~5.4x the starting capital** and **~17.8x the
+   reported profit**.
+
+**Install.**
+
+```bash
+pip install backtest-audit-kit
+```
+
+**Use it in code** (four checkers, pure standard library):
+
+```python
+from auditkit.checks import lookahead
+findings = lookahead.detect_file("strategy.py")   # future-data lint
+print(lookahead.format_findings(findings))
+```
+
+**How to run.**
+
+```bash
+cd portfolio/backtest-audit-kit
+python3 -m unittest discover tests      # stdlib only, no install
+# or, if you have pytest:
+python3 -m pytest tests/ -q
+python3 examples/run_demo.py            # see all four checkers in action
+```
+
+**Honesty note.** The look-ahead checker is a heuristic linter, not a proof
+engine: it flags the *shapes* that leak, and a stand-alone forward-simulation
+pass is reported `MEDIUM` for human review rather than being declared safe.
+Mutation testing reports blind spots; it never claims your strategy is
+profitable. No checker here predicts returns.
+
+---
+
+## 中文
+
+**是什么。** 一个纯 Python 标准库（3.9+）实现的回测审计工具包，四个互相独立
+的检查器：
+
+| 检查器 | 回答的问题 |
+|---|---|
+| `checks/lookahead.py` | 在 bar `i` 上的决策，是否读到了 `i+1...` 的数据？（基于 AST 的前视/未来函数检测） |
+| `checks/invariants.py` | 账本是否满足会计不变量？（权益恒等式、`wd_cum` 结转、计数器单调、余额非负） |
+| `checks/mutants.py` | 你的测试套件**抓不到**哪些 bug？（变异测试；存活的变异体 = 覆盖盲区） |
+| `checks/fees.py` | 手续费是否双边计、资金费是否逐 bar 计、滑点是否每笔只算一次？ |
+
+**给谁用。** 量化开发者、自营研究岗、以及任何"回测很美、实盘就死"过的
+人。带看别人的回测（或自己的）时，它给你的是**问题清单 + 复现脚本 + 修复前后
+的数字**，而不是一句"我觉得不太行"。
+
+**交付物承诺。** ① 按严重度排序的问题清单，每个问题配一个可运行的复现脚本。
+② 最小修复补丁。③ 修复前后的对账数字（胜率 / 净利 / 倍数 / 回撤 / t 值）。
+
+**案例摘要**（完整写在 `cases/`）：
+
+1. **前视 bug** —— 出场扫描写在开仓 bar 的循环内，每个信号都提前知道结果。
+   修复后：91 笔 / 90.1% / **+$214.37** → 26 笔 / 65.4% / **-$0.12**；tick 级
+   复跑得 27 笔 / 66.7% / **+$0.37**。这个泄漏值 **约 $214 的虚假收益**，
+   即全部利润。
+2. **提现会计 bug** —— 爆仓返程丢了 `wd_cum`，导致所有带提现的策略历史收益被
+   系统性低估。修复后：同一配置 2024–26 **7.82x → 215.27x**（相差约 27 倍；
+   提现规则"翻 2 留 1"与"翻 200 留 100"之间也差约 27 倍）。
+3. **回撤口径 bug** —— 熔断触发时把 peak 重置为 cap，"报告 MDD"只是每段熔断
+   后的局部回撤。投资者口径的原始回撤 **99.7%** vs 报告 **53.1%**，**差 46
+   个百分点**。结论：MDD 必须双写（熔断口径 + 原始口径）。
+   （**附赠案例 4**：一段暴跌连打十几根 5min bar 让样本量虚增约 11 倍，t 值从
+   15.60 在 24h 冷却去重后掉到 1.75。）
+4. **成本漏算**（`cases/case5_cost_omission.md`）—— 一个高换手 50x 账本**完全没算**手续费/资金费/滑点；止盈只需价格动 **+0.08%**，而一趟往返 **0.09%**（场馆真实 4.5bps taker）⇒ 目标在成本之下，每笔赢单净亏。按场馆真实费率，漏掉的成本约 **5.4× 本金**、**17.8× 账面收益**。
+
+**怎么跑。**
+
+```bash
+cd portfolio/backtest-audit-kit
+python3 -m unittest discover tests      # 只用标准库，无需安装
+# 若装了 pytest：
+python3 -m pytest tests/ -q
+python3 examples/run_demo.py            # 四个检查器全跑一遍
+```
+
+**诚实声明。** 前视检查器是启发式 linter，不是证明器：它抓的是会泄漏的**代码
+形态**，独立的"向前模拟"循环会被标为 `MEDIUM` 交人工复核，而不是被判安全。
+变异测试只报告覆盖盲区，从不声称你的策略赚钱。本工具包不预测任何收益。
+
+---
+
+## Also in this account · 另见
+
+- [`outpost/`](./outpost/) — 一个"只放能跑、能查、能被否证的东西"的据点：
+  单文件表格整理工具（零依赖、离线自检 14 项）+ 一份**被自己推翻**的回测（做空山寨无 edge）
+  + 一次"两条腿都断了"的数据源修复。不写客户名、不写"我能做什么"。

backtest_audit_kit-0.1.0/auditkit/__init__.py

@@ -0,0 +1,16 @@
+"""auditkit — a tiny, dependency-free toolkit for auditing backtests.
+
+The toolkit answers one question: *is this strategy real, or did the backtest
+lie to you?*  It ships four independent checkers:
+
+* ``auditkit.checks.lookahead``   — AST-based look-ahead / future-function lint.
+* ``auditkit.checks.invariants``  — ledger invariants (equity identity, wd_cum, monotonic counters).
+* ``auditkit.checks.mutants``     — mutation testing: which bugs would your tests *not* catch?
+* ``auditkit.checks.fees``        — fee / funding / slippage accounting checks.
+
+Everything is pure standard library (Python 3.9+).  No pandas, no numpy,
+no network access.
+"""
+
+__version__ = "0.1.0"
+__all__ = ["checks"]

backtest_audit_kit-0.1.0/auditkit/checks/__init__.py

@@ -0,0 +1,5 @@
+"""Checkers bundled with auditkit."""
+
+from . import fees, invariants, lookahead, mutants
+
+__all__ = ["lookahead", "invariants", "mutants", "fees"]

backtest_audit_kit-0.1.0/auditkit/checks/fees.py

@@ -0,0 +1,184 @@
+"""Fee / funding / slippage accounting.
+
+Costs are where optimistic backtests hide.  Three failure modes dominate:
+
+* **one-sided fees** — the engine charges the entry fee but forgets the exit
+  (or vice-versa), so every trade is quietly cheaper than reality;
+* **funding charged once** — a perp position held for ``k`` bars should pay
+  funding ``k`` times, but the engine deducts a single period;
+* **double-counted slippage** — slippage is applied to both the raw fill *and*
+  the already-slippaged price, charging it twice per fill.
+
+Each trade is a ``dict``::
+
+    {
+      "id": "t1",
+      "entry_notional": 10_000.0,
+      "exit_notional": 10_000.0,   # optional, defaults to entry_notional
+      "holding_bars": 8,
+      "fee_paid": 10.0,            # total round-trip fee actually charged
+      "funding_paid": 8.0,         # total funding actually charged
+      "slippage_paid": 4.0,        # total slippage cost actually charged
+    }
+
+Rates are in **basis points** (1 bp = 0.01%).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional, Sequence
+
+__all__ = ["FeeIssue", "check_trades", "check_trade", "DEFAULT_RATES"]
+
+BPS = 10_000.0
+DEFAULT_RATES = {
+    "fee_bps": 5.0,            # per side (taker)
+    "funding_bps_per_bar": 1.0,
+    "slippage_bps": 2.0,       # per fill
+}
+REL_TOL = 0.05  # 5% tolerance on each estimate
+
+
+@dataclass(frozen=True)
+class FeeIssue:
+    rule: str
+    trade_id: object
+    message: str
+    expected: Optional[float] = None
+    actual: Optional[float] = None
+
+    def as_dict(self) -> dict:
+        return {
+            "rule": self.rule,
+            "trade_id": self.trade_id,
+            "message": self.message,
+            "expected": self.expected,
+            "actual": self.actual,
+        }
+
+    def __str__(self) -> str:  # pragma: no cover - cosmetic
+        return f"[{self.rule}] trade={self.trade_id}: {self.message}"
+
+
+def _f(trade: dict, key: str, default: float = 0.0) -> float:
+    val = trade.get(key, default)
+    try:
+        return float(val)
+    except (TypeError, ValueError):
+        return default
+
+
+def _outside(actual: float, expected: float, rel_tol: float) -> Optional[str]:
+    """Return ``"low"``, ``"high"``, or ``None`` relative to ``expected``."""
+    if expected <= 0:
+        return "high" if actual > 1e-9 else None
+    ratio = actual / expected
+    if ratio < 1 - rel_tol:
+        return "low"
+    if ratio > 1 + rel_tol:
+        return "high"
+    return None
+
+
+def check_trade(
+    trade: dict,
+    fee_bps: float = DEFAULT_RATES["fee_bps"],
+    funding_bps_per_bar: float = DEFAULT_RATES["funding_bps_per_bar"],
+    slippage_bps: float = DEFAULT_RATES["slippage_bps"],
+    rel_tol: float = REL_TOL,
+) -> List[FeeIssue]:
+    issues: List[FeeIssue] = []
+    tid = trade.get("id", "?")
+    entry = _f(trade, "entry_notional")
+    exit_n = _f(trade, "exit_notional", entry) or entry
+    bars = int(_f(trade, "holding_bars", 1)) or 1
+
+    # --- round-trip fees (both sides) ------------------------------------- #
+    expected_fee = (entry + exit_n) * fee_bps / BPS
+    actual_fee = _f(trade, "fee_paid", float("nan"))
+    if actual_fee == actual_fee:  # not NaN -> provided
+        side = _outside(actual_fee, expected_fee, rel_tol)
+        if side == "low":
+            issues.append(
+                FeeIssue(
+                    "ONE_SIDED_FEE",
+                    tid,
+                    f"fee {actual_fee:.4f} < round-trip expectation "
+                    f"{expected_fee:.4f} (entry+exit) -- likely only one side charged",
+                    expected_fee,
+                    actual_fee,
+                )
+            )
+        elif side == "high":
+            issues.append(
+                FeeIssue(
+                    "FEE_OVERCHARGE",
+                    tid,
+                    f"fee {actual_fee:.4f} > round-trip expectation {expected_fee:.4f}",
+                    expected_fee,
+                    actual_fee,
+                )
+            )
+
+    # --- funding per bar -------------------------------------------------- #
+    expected_funding = entry * funding_bps_per_bar / BPS * bars
+    actual_funding = _f(trade, "funding_paid", float("nan"))
+    if actual_funding == actual_funding and bars > 1:
+        side = _outside(actual_funding, expected_funding, rel_tol)
+        if side == "low":
+            issues.append(
+                FeeIssue(
+                    "FUNDING_ONCE",
+                    tid,
+                    f"funding {actual_funding:.4f} for {bars} bars < "
+                    f"{expected_funding:.4f} -- charged once, not per bar",
+                    expected_funding,
+                    actual_funding,
+                )
+            )
+        elif side == "high":
+            issues.append(
+                FeeIssue(
+                    "FUNDING_OVERCHARGE",
+                    tid,
+                    f"funding {actual_funding:.4f} > {expected_funding:.4f} "
+                    f"for {bars} bars",
+                    expected_funding,
+                    actual_funding,
+                )
+            )
+
+    # --- slippage once per fill (round trip = two fills) ------------------ #
+    expected_slip = (entry + exit_n) * slippage_bps / BPS
+    actual_slip = _f(trade, "slippage_paid", float("nan"))
+    if actual_slip == actual_slip:
+        side = _outside(actual_slip, expected_slip, rel_tol)
+        if side == "high":
+            issues.append(
+                FeeIssue(
+                    "SLIPPAGE_MULTIPLE",
+                    tid,
+                    f"slippage {actual_slip:.4f} > one-pass expectation "
+                    f"{expected_slip:.4f} -- slippage looks double-counted",
+                    expected_slip,
+                    actual_slip,
+                )
+            )
+
+    return issues
+
+
+def check_trades(
+    trades: Sequence[dict],
+    fee_bps: float = DEFAULT_RATES["fee_bps"],
+    funding_bps_per_bar: float = DEFAULT_RATES["funding_bps_per_bar"],
+    slippage_bps: float = DEFAULT_RATES["slippage_bps"],
+    rel_tol: float = REL_TOL,
+) -> List[FeeIssue]:
+    out: List[FeeIssue] = []
+    for trade in trades:
+        out.extend(
+            check_trade(trade, fee_bps, funding_bps_per_bar, slippage_bps, rel_tol)
+        )
+    return out