Spaces:
Running
Running
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)),
},
)
|