Backtest on Hyperliquid whale and smart money positions — hour by hour, as they were then

"""Does the smart cohort's BTC positioning say anything about the next hour's return? A point-in-time check.

Run:  VIKE_API_KEY=... python hl-cohort-backtest.py    (--dry-run lists the requests and makes none)
"""
import os
import sys
from datetime import datetime
from statistics import correlation, mean
from urllib.parse import urlencode

NAME = "hl-cohort-backtest"
BASE = "https://data.vike.io"
DRY = "--dry-run" in sys.argv
COHORT = "3x smart"
HOUR_MS = 3_600_000


def fail(why):
    sys.exit(f"{NAME}: {why}")


def call(path, method="GET", **params):
    url = BASE + path + ("?" + urlencode(params) if params else "")
    if DRY:
        print(method, url)
        return None
    key = os.environ.get("VIKE_API_KEY") or fail("set VIKE_API_KEY")
    import requests

    r = requests.request(method, url, headers={"X-API-Key": key}, timeout=60)
    if r.status_code != 200:
        fail(f"{method} {path} answered HTTP {r.status_code}: {r.text[:200]}")
    return r.json()


def main():
    # labelBasis=point_in_time: each row carries the label the wallet had THAT hour. The default
    # resolves labels at query time, which hands a backtest today's grading (lookahead).
    matrix = call(
        "/v1/hl-cohorts/symbols/BTC/cohort-metrics",
        axis="pnl", labelBasis="point_in_time", hours=800,
        start="2026-10-01T00:00:00Z", end="2026-10-31T00:00:00Z",
    )
    candles = call(
        "/v1/hyperliquid/ohlcv",
        symbol="BTC", interval="1h", limit=800,
        start="2026-10-01T00:00:00Z", end="2026-10-31T02:00:00Z",
    )
    if DRY:
        return
    if matrix["label_basis"] != "point_in_time":
        fail("labels are not point-in-time; a backtest on them would look ahead")

    ret = {c["ts"]: c["close"] / c["open"] - 1 for c in candles["candles"]}
    pairs = []  # (bias in hour H, return of hour H+1): positioning is read before the move it is compared to
    for m in matrix["metrics"]:
        if m["cohort"] != COHORT or m["bias"] is None:
            continue
        hour_ms = int(datetime.fromisoformat(m["ts"]).timestamp() * 1000)
        if hour_ms + HOUR_MS in ret:
            pairs.append((m["bias"], ret[hour_ms + HOUR_MS]))
    if len(pairs) < 10:
        fail(f"only {len(pairs)} usable hours for cohort {COHORT!r}")

    long_side = [r for b, r in pairs if b > 0]
    short_side = [r for b, r in pairs if b <= 0]
    print(f"{COHORT}, BTC, {len(pairs)} hours (labels: point_in_time)")
    print(f"  corr(bias, next-hour return) = {correlation([b for b, _ in pairs], [r for _, r in pairs]):+.3f}")
    if long_side:
        print(f"  next-hour return after net-long hours : {mean(long_side) * 1e4:+.1f} bp over {len(long_side)} hours")
    if short_side:
        print(f"  next-hour return after net-short hours: {mean(short_side) * 1e4:+.1f} bp over {len(short_side)} hours")


if __name__ == "__main__":
    try:
        main()
    except Exception as e:  # a shape the example does not expect fails by name, not by traceback
        fail(f"{type(e).__name__}: {e}")

import os
from datetime import datetime
from statistics import correlation, mean

import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment
API = "https://data.vike.io"
H = 3_600_000  # an hour in ms


def get(path, **params):
    r = requests.get(API + path, params=params, headers={"X-API-Key": API_KEY}, timeout=120)
    r.raise_for_status()
    return r.json()


def ms(ts):
    """An ISO hour as epoch ms, the unit /ohlcv's `ts` is in."""
    return int(datetime.fromisoformat(ts).timestamp() * 1000)
START, END = "2026-10-01T00:00:00Z", "2026-10-31T00:00:00Z"  # 30 days, the window of the script above
COHORT = "3x rekt"  # the cohort today's labels move to the other side most often (32% of hours, 2026-11-04)

c = get("/v1/hyperliquid/ohlcv", symbol="BTC", interval="1h", start=START, end="2026-10-31T02:00:00Z", limit=800)
ret = {int(b["ts"]): b["close"] / b["open"] - 1 for b in c["candles"]}
for basis in ("point_in_time", "current"):  # each hour's own labels, then today's stamped on every hour
    m = get("/v1/hl-cohorts/symbols/BTC/cohort-metrics", axis="pnl", labelBasis=basis, start=START, end=END, hours=800)
    pairs = [(r["bias"], ret[ms(r["ts"]) + H]) for r in m["metrics"]
             if r["cohort"] == COHORT and r["bias"] is not None and ms(r["ts"]) + H in ret]
    up = [x for b, x in pairs if b > 0]
    print(f"{basis:<13} lookahead={m['label_computed']['lookahead']!s:<5} {COHORT} net long {len(up)} of {len(pairs)} hours, "
          f"corr(bias, next-hour return) {correlation(*zip(*pairs)):+.3f}")

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# BTC's hourly pnl-cohort matrix over one week, labels as they were each hour
r = requests.get(
    "https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=pnl&labelBasis=point_in_time&start=2026-10-13T00:00:00Z&end=2026-10-19T23:59:59Z&hours=168",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# BTC hourly candles over the same week plus six hours
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv?symbol=BTC&interval=1h&start=2026-10-13T00:00:00Z&end=2026-10-20T06:00:00Z&limit=200",
    headers={"X-API-Key": API_KEY},
)

import os
from datetime import datetime
from statistics import correlation, mean

import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment
API = "https://data.vike.io"
H = 3_600_000  # an hour in ms


def get(path, **params):
    r = requests.get(API + path, params=params, headers={"X-API-Key": API_KEY}, timeout=120)
    r.raise_for_status()
    return r.json()


def ms(ts):
    """An ISO hour as epoch ms, the unit /ohlcv's `ts` is in."""
    return int(datetime.fromisoformat(ts).timestamp() * 1000)
START, END = "2026-08-07T00:00:00Z", "2026-11-03T23:59:59Z"  # 89 days; from 08-07 every pnl hour is labelled hourly
COHORT, WINDOW, Z, AHEAD = "3x rekt", 168, 2.0, 6  # extreme = 2 sd from its trailing week; the next 6 hours

# the cohort's bias every hour, each wallet labelled as it stood THAT hour, not today
m = get("/v1/hl-cohorts/symbols/BTC/cohort-metrics", axis="pnl", labelBasis="point_in_time",
        start=START, end=END, hours=2200)
assert m["label_computed"]["lookahead"] is False
bias = {ms(r["ts"]): r["bias"] for r in m["metrics"] if r["cohort"] == COHORT and r["bias"] is not None}
# hourly closes, past the window's end for the last forward return (`end` is exclusive here)
c = get("/v1/hyperliquid/ohlcv", symbol="BTC", interval="1h", start=START, end="2026-11-05T00:00:00Z", limit=5000)
close = {int(b["ts"]): b["close"] for b in c["candles"]}

hours = sorted(bias)
every, events, skip_to = [], {"long": [], "short": []}, 0
for i, t in enumerate(hours[WINDOW:], WINDOW):
    if t not in close or t + AHEAD * H not in close:
        continue
    ret = close[t + AHEAD * H] / close[t] - 1  # from the close of the bias hour
    every.append(ret)
    past = [bias[h] for h in hours[i - WINDOW:i]]
    mu = mean(past)
    sd = (sum((x - mu) ** 2 for x in past) / len(past)) ** 0.5
    z = (bias[t] - mu) / sd if sd else 0
    if t >= skip_to and abs(z) > Z:  # one extreme is one event: skip the hours its forward return covers
        events["long" if z > 0 else "short"].append(ret)
        skip_to = t + AHEAD * H

print(f"{COHORT}, BTC, {len(every)} hours scored, labels point_in_time")
print(f"  every hour: next {AHEAD}h {mean(every) * 1e4:+.1f} bp on average")
for side, xs in events.items():
    if xs:
        right = sum(1 for r in xs if (r < 0 if side == "long" else r > 0))
        print(f"  most {side} (z {'>' if side == 'long' else '<'} {'' if side == 'long' else '-'}{Z}): {len(xs)} events, "
              f"next {AHEAD}h {mean(xs) * 1e4:+.1f} bp on average, fading it was right {right} of {len(xs)}")

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# BTC's hourly Smart Money Index over 30 days, one page
r = requests.get(
    "https://data.vike.io/v1/hl-cohorts/symbols/BTC/indices?start=2026-10-05T00:00:00Z&end=2026-11-03T23:59:59Z",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# BTC hourly candles over the same 30 days and one day past them; end is exclusive here
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv?symbol=BTC&interval=1h&start=2026-10-05T00:00:00Z&end=2026-11-05T00:00:00Z&limit=800",
    headers={"X-API-Key": API_KEY},
)

import os
from datetime import datetime
from statistics import correlation, mean

import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment
API = "https://data.vike.io"
H = 3_600_000  # an hour in ms


def get(path, **params):
    r = requests.get(API + path, params=params, headers={"X-API-Key": API_KEY}, timeout=120)
    r.raise_for_status()
    return r.json()


def ms(ts):
    """An ISO hour as epoch ms, the unit /ohlcv's `ts` is in."""
    return int(datetime.fromisoformat(ts).timestamp() * 1000)
START, END = "2026-08-07T00:00:00Z", "2026-11-03T23:59:59Z"  # 89 days; from 08-07 every pnl hour is labelled hourly
s = get("/v1/hl-cohorts/symbols/BTC/indices", start=START, end=END)
assert not s["has_more"]  # 2,136 hours: one page (up to 5,000 rows)
smi = {ms(r["ts"]): r["smi"] for r in s["series"] if r["smi"] is not None}
c = get("/v1/hyperliquid/ohlcv", symbol="BTC", interval="1h", start=START, end="2026-11-05T00:00:00Z", limit=5000)
close = {int(b["ts"]): b["close"] for b in c["candles"]}

print(f"BTC Smart Money Index, {len(smi)} hours, {START[:10]} to {END[:10]}")
for k in (1, 4, 12, 24):
    pairs = [(v, close[t + k * H] / close[t] - 1) for t, v in smi.items() if t in close and t + k * H in close]
    print(f"  corr(smi at t, return t -> t+{k}h) {correlation(*zip(*pairs)):+.3f} over {len(pairs)} hours")
# the fifth of hours with the highest SMI against the fifth with the lowest, next 24 hours
pairs = sorted((v, close[t + 24 * H] / close[t] - 1) for t, v in smi.items() if t in close and t + 24 * H in close)
n = len(pairs) // 5
print(f"  next 24h after the top fifth of SMI {mean(r for _, r in pairs[-n:]) * 1e4:+.0f} bp, "
      f"after the bottom fifth {mean(r for _, r in pairs[:n]) * 1e4:+.0f} bp")

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# ETH's hourly indices over four hours of 2026-10-20
r = requests.get(
    "https://data.vike.io/v1/hl-cohorts/symbols/ETH/indices?start=2026-10-20T00:00:00Z&end=2026-10-20T03:00:00Z",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# ETH's hourly indices from 2026-08-07 to 2026-11-03: 2,136 hours, one page
r = requests.get(
    "https://data.vike.io/v1/hl-cohorts/symbols/ETH/indices?start=2026-08-07T00:00:00Z&end=2026-11-03T23:59:59Z",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# ETH hourly candles over the same window and one day past it
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv?symbol=ETH&interval=1h&start=2026-08-07T00:00:00Z&end=2026-11-05T00:00:00Z&limit=5000",
    headers={"X-API-Key": API_KEY},
)

import os
from datetime import datetime
from statistics import correlation, mean

import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment
API = "https://data.vike.io"
H = 3_600_000  # an hour in ms


def get(path, **params):
    r = requests.get(API + path, params=params, headers={"X-API-Key": API_KEY}, timeout=120)
    r.raise_for_status()
    return r.json()


def ms(ts):
    """An ISO hour as epoch ms, the unit /ohlcv's `ts` is in."""
    return int(datetime.fromisoformat(ts).timestamp() * 1000)
START, END = "2026-08-07T00:00:00Z", "2026-11-03T23:59:59Z"  # 89 days; from 08-07 every pnl hour is labelled hourly
WINDOW, Z, AHEAD = 720, 2.0, 24  # z against the trailing 30 days; the next 24 hours

s = get("/v1/hl-cohorts/symbols/ETH/indices", start=START, end=END)
assert not s["has_more"]
wsi = {ms(r["ts"]): r["wsi"] for r in s["series"] if r["wsi"] is not None}  # null when a side holds nothing
c = get("/v1/hyperliquid/ohlcv", symbol="ETH", interval="1h", start=START, end="2026-11-05T00:00:00Z", limit=5000)
close = {int(b["ts"]): b["close"] for b in c["candles"]}

hours = sorted(wsi)
events, skip_to, scored = [], 0, 0
for i, t in enumerate(hours[WINDOW:], WINDOW):
    if t not in close or t + AHEAD * H not in close:
        continue
    scored += 1
    past = [wsi[h] for h in hours[i - WINDOW:i]]
    mu = mean(past)
    sd = (sum((x - mu) ** 2 for x in past) / len(past)) ** 0.5
    z = (wsi[t] - mu) / sd if sd else 0
    if t >= skip_to and abs(z) > Z:  # count events, not hours: forward returns of neighbouring hours overlap
        events.append((z, close[t + AHEAD * H] / close[t] - 1))
        skip_to = t + AHEAD * H

print(f"ETH Whale-vs-Shrimp Index, {scored} hours scored, {len(events)} extremes (|z| > {Z})")
for name, xs in (("whales most long", [r for z, r in events if z > 0]), ("whales most short", [r for z, r in events if z < 0])):
    if xs:
        against = sum(1 for r in xs if (r < 0 if name.endswith("long") else r > 0))
        print(f"  {name}: {len(xs)} events, next {AHEAD}h {mean(xs) * 1e4:+.0f} bp on average, "
              f"price went against the whales {against} of {len(xs)}")

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# BTC open position size by account-value cohort, 25 hourly buckets
r = requests.get(
    "https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=size&hours=25",
    headers={"X-API-Key": API_KEY},
)

"""Net buying or selling of one coin by cohort, hour by hour: the change in long size minus the change in short size.

Run:  VIKE_API_KEY=... python hl-cohort-net-flow.py    (--dry-run lists the requests and makes none)
"""
import os
import sys
from datetime import datetime, timezone
from urllib.parse import urlencode

NAME = "hl-cohort-net-flow"
BASE = "https://data.vike.io"
DRY = "--dry-run" in sys.argv
COIN = "BTC"


def fail(why):
    sys.exit(f"{NAME}: {why}")


def call(path, method="GET", **params):
    url = BASE + path + ("?" + urlencode(params) if params else "")
    if DRY:
        print(method, url)
        return None
    key = os.environ.get("VIKE_API_KEY") or fail("set VIKE_API_KEY")
    import requests

    r = requests.request(method, url, headers={"X-API-Key": key}, timeout=60)
    if r.status_code != 200:
        fail(f"{method} {path} answered HTTP {r.status_code}: {r.text[:200]}")
    return r.json()


def net_flow(metrics: list[dict]) -> dict[str, list[tuple[int, float]]]:
    """cohort -> [(epoch seconds of the hour, flow)], flow in tokens of the coin, + = buying.

    flow(t) = (long(t) - long(prev)) - (short(t) - short(prev)). The grid is the hours present in `metrics`;
    a cohort with no row in one of them held nothing there (0, not a hole); an hour missing for the whole
    coin is a gap the next hour's flow spans; the first hour is a baseline and gets no point.
    """
    sizes = {}  # cohort -> {hour: (long, short)}
    for m in metrics:
        if m["cohort"] in ("unknown", ""):  # `unknown` (pnl: under 10 closed trades; size: on some hours, cause not established here) and '': dropped on the site too
            continue
        for field in ("total_position_size", "total_position_size_long"):
            if m[field] is None:
                fail(f"{field} is null for {m['cohort']} at {m['ts']} (a point-in-time pnl matrix has none before 2026-08-07)")
        total, long_ = m["total_position_size"], m["total_position_size_long"]
        hour = int(datetime.fromisoformat(m["ts"]).timestamp())
        sizes.setdefault(m["cohort"], {})[hour] = (long_, total - long_)
    hours = sorted({h for by_hour in sizes.values() for h in by_hour})
    flows = {}
    for cohort, by_hour in sizes.items():
        points = []
        for prev, t in zip(hours, hours[1:]):
            l0, s0 = by_hour.get(prev, (0.0, 0.0))
            l1, s1 = by_hour.get(t, (0.0, 0.0))
            points.append((t, round((l1 - l0) - (s1 - s0), 6)))  # rounded to 6 places, as the website does
        flows[cohort] = points
    return flows


def main():
    # 25 hourly buckets give 24 changes: the oldest hour is only the baseline of the first one.
    matrix = call(f"/v1/hl-cohorts/symbols/{COIN}/cohort-metrics", axis="size", hours=25)
    if DRY:
        return
    flows = net_flow(matrix["metrics"])
    if not any(flows.values()):
        fail(f"fewer than two hourly buckets of {COIN} came back")
    stamp = lambda t: datetime.fromtimestamp(t, timezone.utc).strftime("%Y-%m-%d %H:%M")
    some = next(iter(flows.values()))  # every cohort has a point at every hour of the grid
    print(f"{COIN} net flow by cohort, {len(some)} hourly changes, {stamp(some[0][0])} to {stamp(some[-1][0])} UTC")
    print(f"tokens of {COIN}; positive = buying (longs up or shorts down)")
    print(f"  {'cohort':<11}{'last hour':>12}{'window':>12}")
    for cohort, pts in flows.items():
        print(f"  {cohort:<11}{pts[-1][1]:>+12,.2f}{sum(f for _, f in pts):>+12,.2f}")


if __name__ == "__main__":
    try:
        main()
    except Exception as e:  # a shape the example does not expect fails by name, not by traceback
        fail(f"{type(e).__name__}: {e}")

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# the same matrix on the realized-PnL ladder, each hour labelled as it was that hour
r = requests.get(
    "https://data.vike.io/v1/hl-cohorts/symbols/BTC/cohort-metrics?axis=pnl&labelBasis=point_in_time&hours=25",
    headers={"X-API-Key": API_KEY},
)

import os
from datetime import datetime
from statistics import correlation, mean

import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment
API = "https://data.vike.io"
H = 3_600_000  # an hour in ms


def get(path, **params):
    r = requests.get(API + path, params=params, headers={"X-API-Key": API_KEY}, timeout=120)
    r.raise_for_status()
    return r.json()


def ms(ts):
    """An ISO hour as epoch ms, the unit /ohlcv's `ts` is in."""
    return int(datetime.fromisoformat(ts).timestamp() * 1000)
START, END = "2026-10-04T00:00:00Z", "2026-11-03T23:59:59Z"  # 30 days
WHALES = {"4x whale", "3x whale", "2x whale", "whale"}
SHRIMP = {"2x shrimp", "shrimp"}

m = get("/v1/hl-cohorts/symbols/BTC/cohort-metrics", axis="size", start=START, end=END, hours=800)
c = get("/v1/hyperliquid/ohlcv", symbol="BTC", interval="1h", start=START, end="2026-11-05T00:00:00Z", limit=5000)
close = {int(b["ts"]): b["close"] for b in c["candles"]}

# each group's long and short size in BTC per hour; a cohort missing from an hour held nothing (0)
size = {"whales": {}, "shrimp": {}}
for r in m["metrics"]:
    g = "whales" if r["cohort"] in WHALES else "shrimp" if r["cohort"] in SHRIMP else None
    if g:
        long_, total = r["total_position_size_long"], r["total_position_size"]
        acc = size[g].setdefault(ms(r["ts"]), [0.0, 0.0])
        acc[0] += long_
        acc[1] += total - long_
hours = sorted({ms(r["ts"]) for r in m["metrics"]})
print(f"BTC, {len(hours) - 1} hourly changes, {START[:10]} to {END[:10]}; flow in BTC, + = buying")
for g, by in size.items():
    flow = {}
    for prev, t in zip(hours, hours[1:]):
        (l0, s0), (l1, s1) = by.get(prev, (0.0, 0.0)), by.get(t, (0.0, 0.0))
        flow[t] = (l1 - l0) - (s1 - s0)
    same = [(f, close[t] / close[t - H] - 1) for t, f in flow.items() if t in close and t - H in close]
    nxt = [(f, close[t + H] / close[t] - 1) for t, f in flow.items() if t in close and t + H in close]
    print(f"  {g:<7} corr(flow, the same hour's return) {correlation(*zip(*same)):+.3f}, "
          f"corr(flow, the next hour's return) {correlation(*zip(*nxt)):+.3f}")

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# a 7-day link to every 5-minute position snapshot of 2026-10-23
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/url?dataset=positions&date=2026-10-23",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# the newest day that has a positions file
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/datasets",
    headers={"X-API-Key": API_KEY},
)
# then: jq '[.dates[] | select(.streams.positions)][0]'

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# BTC positions held by 3x smart wallets in the 12:00 hour of 2026-10-22, one row per wallet and hour
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/positions?symbol=BTC&axis=pnl&cohort=3x_smart&start=2026-10-22T12:00:00Z&end=2026-10-22T12:59:59Z&resolution=1h&limit=3",
    headers={"X-API-Key": API_KEY},
)

import os
from statistics import correlation

import polars as pl
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment
API = "https://data.vike.io"
DAYS = ("2026-10-28", "2026-10-29", "2026-10-30", "2026-10-31", "2026-11-01", "2026-11-02", "2026-11-03")
SMART = ["3x smart", "2x smart", "smart"]
H = 3_600_000


def get(path, **params):
    r = requests.get(API + path, params=params, headers={"X-API-Key": API_KEY}, timeout=120)
    r.raise_for_status()
    return r.json()


# the smart cohorts' net BTC position at every 5-minute snapshot, each row labelled as of the start of its hour
book = []
for day in DAYS:
    url = get("/v1/hyperliquid/archive/url", dataset="positions", date=day)["url"]
    book.append(pl.scan_parquet(url)  # polars reads only BTC's byte ranges off the link
                .filter((pl.col("asset") == "BTC") & pl.col("pnl_cohort").is_in(SMART))
                .group_by("snapshot_ts").agg((pl.col("direction") * pl.col("size_token")).sum().alias("net_btc"))
                .collect())
book = pl.concat(book).sort("snapshot_ts")
# the book at the hour's last snapshot; its change over the hour is the signal
hourly = (book.with_columns(pl.col("snapshot_ts").dt.truncate("1h").dt.epoch("ms").alias("t"))
          .group_by("t", maintain_order=True).agg(pl.col("net_btc").last()))
net = dict(zip(hourly["t"].to_list(), hourly["net_btc"].to_list()))
c = get("/v1/hyperliquid/ohlcv", symbol="BTC", interval="1h", start=f"{DAYS[0]}T00:00:00Z",
        end="2026-11-04T02:00:00Z", limit=500)
close = {int(b["ts"]): b["close"] for b in c["candles"]}
pairs = [(net[t] - net[t - H], close[t + H] / close[t] - 1) for t in net
         if t - H in net and t in close and t + H in close]
print(f"smart cohorts on BTC, {book.height:,} snapshots over {len(DAYS)} days: net {book['net_btc'][0]:+,.0f} BTC "
      f"at the first, {book['net_btc'][-1]:+,.0f} BTC at the last")
print(f"  corr(the hour's change in their net BTC, the next hour's return) {correlation(*zip(*pairs)):+.3f} "
      f"over {len(pairs)} hours")

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# every BTC fill over $50,000 the feed holds; run it every few minutes and append the new rows to your log
r = requests.get(
    "https://data.vike.io/v1/hl-cohorts/symbols/BTC/large-fills",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# ten minutes of BTC 1-minute candles around the captured fills; end is exclusive
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/ohlcv?symbol=BTC&interval=1m&start=2026-10-24T17:10:00Z&end=2026-10-24T17:20:00Z",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# BTC fills of $250,000 or more still in the feed
r = requests.get(
    "https://data.vike.io/v1/hl-cohorts/symbols/BTC/large-fills?min_usd=250000",
    headers={"X-API-Key": API_KEY},
)

import os
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment

# a temporary link to every fill of 2026-10-23
r = requests.get(
    "https://data.vike.io/v1/hyperliquid/archive/url?dataset=fills&date=2026-10-23",
    headers={"X-API-Key": API_KEY},
)

import os
from datetime import datetime, timedelta
from statistics import mean

import polars as pl
import requests

API_KEY = os.environ["VIKE_API_KEY"]  # your key, read from the environment
API = "https://data.vike.io"
DAYS = ("2026-11-01", "2026-11-02", "2026-11-03")
SMART = ("3x smart", "2x smart", "smart")
MIN_USD, AHEAD = 50_000, 10  # the large-fills floor; the price 10 minutes later


def get(path, **params):
    r = requests.get(API + path, params=params, headers={"X-API-Key": API_KEY}, timeout=120)
    r.raise_for_status()
    return r.json()


def btc(dataset, day, cols):
    """Only BTC's part of one archive file: polars reads the needed byte ranges straight off the link."""
    url = get("/v1/hyperliquid/archive/url", dataset=dataset, date=day)["url"]
    return pl.scan_parquet(url).filter(pl.col("asset") == "BTC").select(cols).collect()


def hour(col):
    return pl.col(col).dt.replace_time_zone(None).dt.cast_time_unit("ms").dt.truncate("1h").alias("hour")


moves = {"smart wallets": [], "every wallet": []}
labelled = total = 0
for day in DAYS:
    # the taker side of every BTC trade of $50k or more (the fills file carries no cohort)
    fills = (btc("fills", day, ["fill_ts", "wallet", "side", "size_usd", "price", "crossed"])
             .filter(pl.col("crossed") & (pl.col("size_usd") >= MIN_USD))
             .with_columns(hour("fill_ts"), (pl.col("fill_ts").dt.epoch("ms") // 60_000 * 60_000).alias("minute")))
    # the label: the positions file's pnl_cohort, graded on fills strictly BEFORE the row's hour, so it cannot see the fill
    labels = (btc("positions", day, ["snapshot_ts", "wallet", "pnl_cohort"])
              .with_columns(hour("snapshot_ts")).group_by("wallet", "hour").agg(pl.col("pnl_cohort").first()))
    f = fills.join(labels, on=["wallet", "hour"], how="left")
    total += f.height
    labelled += f.filter(pl.col("pnl_cohort").is_not_null()).height
    end = (datetime.fromisoformat(day) + timedelta(days=1, minutes=AHEAD + 1)).strftime("%Y-%m-%dT%H:%M:%SZ")
    bars = get("/v1/hyperliquid/ohlcv", symbol="BTC", interval="1m", start=f"{day}T00:00:00Z", end=end, limit=5000)
    close = {int(b["ts"]): b["close"] for b in bars["candles"]}
    for row in f.iter_rows(named=True):
        later = close.get(row["minute"] + AHEAD * 60_000)
        if later is None:
            continue
        move = (1 if row["side"] == "buy" else -1) * (later / row["price"] - 1)  # + = price went the fill's way
        moves["every wallet"].append(move)
        if row["pnl_cohort"] in SMART:
            moves["smart wallets"].append(move)

print(f"BTC taker fills of ${MIN_USD:,}+ on {DAYS[0]} to {DAYS[-1]}: {total:,}, {labelled / total:.0%} carry a label")
for who, xs in moves.items():
    print(f"  {who:<13} {len(xs):>6,} fills: {AHEAD} min later the price had moved their way "
          f"{mean(xs) * 1e4:+.2f} bp on average, {sum(x > 0 for x in xs) / len(xs):.0%} of the time")