File size: 6,578 Bytes
d4c51f2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
"""Event-driven copy-trade backtest against a single target wallet.

We replay the target's normalized ledger in time order and mirror it with OUR
bankroll, sizing each entry by conviction (sizing.py). Exits mirror the target:
when the target trims/redeems X% of their position, we trim the same % of ours.

Fill model (documented approximations — this is research, not a fill simulator):
  * entry fill  = target's price * (1 + slippage)      # we pay up to get in
  * exit  fill  = target's exit price * (1 - slippage)  # we give up edge to exit
  * redemptions use payout-per-share (usdc/size) as the exit price
  * copy_delay_sec is folded into `slippage_bps` rather than modeled tick-by-tick
    (modeling it exactly needs CLOB prices-history per token; left as a TODO).

Outputs an equity curve and summary stats, and can run a flat-sizing baseline
so you can see whether conviction sizing actually helped.
"""
from __future__ import annotations

from collections import defaultdict
from dataclasses import dataclass

import numpy as np
import pandas as pd

from .sizing import SizingConfig, position_fraction


@dataclass
class BacktestResult:
    equity_curve: pd.DataFrame          # ts, equity, cash, invested
    final_equity: float
    total_return: float
    max_drawdown_pct: float
    n_entries: int
    n_exits: int
    closed_win_rate: float
    summary: dict

    def to_summary(self) -> dict:
        return {
            "final_equity": round(self.final_equity, 2),
            "total_return": round(self.total_return, 4),
            "max_drawdown_pct": round(self.max_drawdown_pct, 4),
            "n_entries": self.n_entries,
            "n_exits": self.n_exits,
            "closed_win_rate": round(self.closed_win_rate, 4),
            **self.summary,
        }


def _trailing_avg(values: list[float], window: int = 20) -> float:
    if not values:
        return 0.0
    return float(np.mean(values[-window:]))


def run(ledger: pd.DataFrame, bankroll: float, sizing: SizingConfig,
        slippage_bps: float = 150, fee_bps: float = 0,
        flat_sizing: bool = False) -> BacktestResult:
    """`flat_sizing=True` ignores conviction and stakes a constant
    max_frac_per_trade on every entry (baseline for comparison)."""
    slip = slippage_bps / 1e4
    fee = fee_bps / 1e4

    cash = bankroll
    our_shares: dict = defaultdict(float)      # asset -> shares WE hold
    tgt_shares: dict = defaultdict(float)      # asset -> shares TARGET holds
    market_cost: dict = defaultdict(float)     # market -> USD we've committed
    last_price: dict = defaultdict(float)      # asset -> last seen price
    asset_market: dict = {}                    # asset -> market id
    entry_cost: dict = defaultdict(float)      # asset -> our cost basis (for win/loss)
    realized: list = []                        # per-closed-lot pnl
    target_buy_usdc: list = []

    curve = []
    n_entries = n_exits = 0

    def mark_equity(ts):
        invested = sum(sh * last_price.get(a, 0.0) for a, sh in our_shares.items())
        curve.append({"ts": ts, "equity": cash + invested,
                      "cash": cash, "invested": invested})

    for row in ledger.itertuples(index=False):
        side, typ = row.side, row.type
        asset, market = row.asset, row.market
        price = float(row.price) if row.price else last_price.get(asset, 0.0)
        size = float(row.size)
        last_price[asset] = price or last_price.get(asset, 0.0)
        asset_market[asset] = market

        if side == "BUY":
            tgt_shares[asset] += size
            target_buy_usdc.append(float(row.usdc))
            rolling = _trailing_avg(target_buy_usdc)

            exposure_frac = market_cost[market] / bankroll
            if flat_sizing:
                frac = max(0.0, min(sizing.max_frac_per_trade,
                                    sizing.max_frac_per_market - exposure_frac))
                conv = float("nan")
            else:
                frac, conv = position_fraction(
                    float(row.usdc), rolling, price, exposure_frac, sizing)

            fill = price * (1 + slip)
            stake = min(frac * bankroll, cash)
            if stake <= 0 or fill <= 0:
                mark_equity(row.ts)
                continue
            stake *= (1 - fee)
            shares = stake / fill
            cash -= stake
            our_shares[asset] += shares
            entry_cost[asset] += stake
            market_cost[market] += stake
            n_entries += 1

        elif side == "SELL" or typ in ("REDEEM", "CLAIM"):
            held = our_shares.get(asset, 0.0)
            tgt_held = tgt_shares.get(asset, 0.0)
            if held > 0 and size > 0 and tgt_held > 0:
                frac_exit = min(1.0, size / tgt_held)
                shares_out = held * frac_exit
                exit_price = (float(row.usdc) / size) if typ in ("REDEEM", "CLAIM") else price
                exec_price = exit_price * (1 - slip)
                proceeds = shares_out * exec_price * (1 - fee)
                cost_out = entry_cost.get(asset, 0.0) * (shares_out / held if held else 0)
                cash += proceeds
                our_shares[asset] -= shares_out
                entry_cost[asset] -= cost_out
                market_cost[asset_market.get(asset, market)] = max(
                    0.0, market_cost.get(market, 0.0) - cost_out)
                realized.append(proceeds - cost_out)
                n_exits += 1
            tgt_shares[asset] = max(0.0, tgt_held - size)

        mark_equity(row.ts)

    if not curve:
        empty = pd.DataFrame(columns=["ts", "equity", "cash", "invested"])
        return BacktestResult(empty, bankroll, 0.0, 0.0, 0, 0, 0.0, {"note": "no trades"})

    eq_df = pd.DataFrame(curve)
    equity = eq_df["equity"].values
    running_max = np.maximum.accumulate(equity)
    max_dd = float(((running_max - equity) / running_max).max())
    final_equity = float(equity[-1])
    closed_wr = float(np.mean([r > 0 for r in realized])) if realized else 0.0

    return BacktestResult(
        equity_curve=eq_df,
        final_equity=final_equity,
        total_return=(final_equity - bankroll) / bankroll,
        max_drawdown_pct=max_dd,
        n_entries=n_entries,
        n_exits=n_exits,
        closed_win_rate=closed_wr,
        summary={
            "bankroll": bankroll,
            "sizing": "flat" if flat_sizing else "conviction",
            "realized_pnl": round(float(sum(realized)), 2),
            "open_lots": int(sum(1 for v in our_shares.values() if v > 1e-9)),
        },
    )