File size: 4,073 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
"""Normalize a wallet's raw activity feed into a tidy trade ledger.

The Data API returns loosely-typed dicts whose exact keys drift over time, so
every field is read with fallbacks. The output is one DataFrame per wallet with
a stable schema the rest of the pipeline relies on.

Cashflow convention (from the trader's perspective):
    BUY               -> cash out (negative)
    SELL              -> cash in  (positive)
    REDEEM / REWARD   -> cash in  (positive)   # market resolved in their favor
Open positions are marked to market separately in metrics.py.
"""
from __future__ import annotations

import pandas as pd

LEDGER_COLS = [
    "ts", "type", "side", "market", "asset", "outcome",
    "size", "price", "usdc", "cashflow", "title",
]

# activity types that bring cash IN (winning redemptions + protocol incentives)
CASH_IN_TYPES = ("REDEEM", "CLAIM", "REWARD", "MAKER_REBATE", "TAKER_REBATE")
# the uncopyable subset: liquidity rewards + maker/taker rebates (market-making)
REBATE_TYPES = ("REWARD", "MAKER_REBATE", "TAKER_REBATE")


def _first(d: dict, *keys, default=None):
    for k in keys:
        if k in d and d[k] not in (None, ""):
            return d[k]
    return default


def _to_float(x, default=0.0) -> float:
    try:
        return float(x)
    except (TypeError, ValueError):
        return default


def normalize_activity(raw: list[dict]) -> pd.DataFrame:
    rows = []
    for a in raw:
        typ = str(_first(a, "type", "activityType", default="TRADE")).upper()
        side = str(_first(a, "side", default="")).upper()
        size = _to_float(_first(a, "size", "shares", "amount"))
        price = _to_float(_first(a, "price", "avgPrice"))
        usdc = _first(a, "usdcSize", "usdc", "usdcValue", default=None)
        usdc = _to_float(usdc) if usdc is not None else round(size * price, 6)

        # ts may be unix seconds or ms
        ts_raw = _to_float(_first(a, "timestamp", "ts", "time"))
        if ts_raw > 1e12:
            ts_raw /= 1000.0
        ts = pd.to_datetime(ts_raw, unit="s", utc=True) if ts_raw else pd.NaT

        # Protocol incentives (liquidity rewards + maker/taker rebates) are real
        # income but NOT copyable directional skill — tag them so metrics can
        # measure how rebate-driven a wallet is (market makers = uncopyable).
        if typ in CASH_IN_TYPES or side == "SELL":
            cashflow = +usdc
        elif side == "BUY":
            cashflow = -usdc
        else:  # unknown non-trade rows contribute no directional cashflow
            cashflow = 0.0

        rows.append({
            "ts": ts,
            "type": typ,
            "side": side,
            "market": _first(a, "conditionId", "condition_id", "market", default=""),
            "asset": _first(a, "asset", "tokenId", "token_id", default=""),
            "outcome": _first(a, "outcome", "outcomeIndex", default=""),
            "size": size,
            "price": price,
            "usdc": usdc,
            "cashflow": cashflow,
            "title": _first(a, "title", "slug", "question", default=""),
        })

    df = pd.DataFrame(rows, columns=LEDGER_COLS)
    if not df.empty:
        df = df.dropna(subset=["ts"]).sort_values("ts").reset_index(drop=True)
    return df


def attach_open_positions(positions: list[dict]) -> pd.DataFrame:
    """Current open positions -> per-market marked-to-market value & PnL."""
    rows = []
    for p in positions:
        size = _to_float(_first(p, "size", "shares"))
        avg = _to_float(_first(p, "avgPrice", "averagePrice"))
        cur = _to_float(_first(p, "curPrice", "currentPrice", "price"))
        rows.append({
            "market": _first(p, "conditionId", "condition_id", "market", default=""),
            "asset": _first(p, "asset", "tokenId", default=""),
            "size": size,
            "avgPrice": avg,
            "curPrice": cur,
            "cost_basis": size * avg,
            "mark_value": size * cur,
            "cashPnl": _to_float(_first(p, "cashPnl", default=size * (cur - avg))),
        })
    return pd.DataFrame(rows)