2. PnL Analytics

const now = Date.now();
const startTime = now - 30 * 24 * 60 * 60 * 1000; // last 30 days

const fills = await info({ type: "userFillsByTime", user: address, startTime });

{
  "coin": "ETH",
  "px": "2410.5",
  "sz": "1.5",
  "side": "A",
  "time": 1753660812345,
  "startPosition": "1.5",
  "dir": "Close Long",
  "closedPnl": "128.40",
  "hash": "0x...",
  "oid": 88123456,
  "fee": "1.81",
  "tid": 445566778899
}

const FILL_CAP = 2000;
const truncated = fills.length >= FILL_CAP;

// Not every fill is backed by a real trade. Synthetic fills (spot dust conversions
// are the common case) carry `tid: 0` and a zero `hash`, so one account can hold
// dozens of distinct fills sharing both. Compose the key from fields that stay
// distinct across them.
const fillKey = (f) => `${f.tid}:${f.oid}:${f.time}:${f.coin}`;

async function fetchAllFills(address, startTime) {
  const all = [];
  let endTime = Date.now();

  while (true) {
    const page = await info({ type: "userFillsByTime", user: address, startTime, endTime });
    if (page.length === 0) break;

    all.push(...page);
    if (page.length < FILL_CAP) break; // partial page, so we've reached the start

    // Step back to just before the oldest fill in this page.
    const oldest = Math.min(...page.map((f) => f.time));
    if (oldest <= startTime) break;
    endTime = oldest - 1;
  }

  // Pages can overlap at boundaries, so de-duplicate, but not on `tid` alone.
  return [...new Map(all.map((f) => [fillKey(f), f])).values()];
}

// Does this fill reduce or flip exposure? `dir` is Hyperliquid's own description of
// what the fill did to the position, so read it rather than inferring from PnL.
//   "Open Long" / "Open Short"      → adds exposure
//   "Close Long" / "Close Short"    → reduces it
//   "Long > Short" / "Short > Long" → flips it (closes, then reopens)
//   "Liquidated …" / "Auto-Deleveraged …" → closed involuntarily
//   "Spot Dust Conversion", "Buy", "Sell"  → spot, no perp exposure at all
function isClosingFill(f) {
  const dir = f.dir ?? "";
  return dir.includes("Close") || dir.includes(">") || /^(Liquidated|Auto-Deleveraged)/.test(dir);
}

function derivePnl(fills) {
  const asc = [...fills].sort((a, b) => a.time - b.time);

  const series = [];         // cumulative realized PnL, one point per fill
  const coins = new Map();   // per-coin breakdown
  let cumulative = 0;
  let fees = 0;
  let volume = 0;
  let closingFills = 0;
  let wins = 0;

  for (const f of asc) {
    const closedPnl = Number(f.closedPnl);
    const fee = Number(f.fee);
    const notional = Math.abs(Number(f.px) * Number(f.sz));

    cumulative += closedPnl - fee;
    fees += fee;
    volume += notional;

    // Win rate counts only fills that closed exposure. Opening fills must not enter
    // the denominator, since including them would tank the rate for everyone.
    if (isClosingFill(f)) {
      closingFills++;
      if (closedPnl > 0) wins++;
    }

    series.push({ time: f.time, value: cumulative });

    const row = coins.get(f.coin) ?? { coin: f.coin, realizedPnl: 0, volume: 0, fills: 0 };
    row.realizedPnl += closedPnl - fee;
    row.volume += notional;
    row.fills++;
    coins.set(f.coin, row);
  }

  return {
    series,
    realizedPnl: cumulative,
    fees,
    volume,
    totalFills: asc.length,
    closingFills,
    winRate: closingFills > 0 ? wins / closingFills : null,
    byCoin: [...coins.values()].sort((a, b) => b.volume - a.volume),
    truncated: asc.length >= 2000,
  };
}

const funding = await info({ type: "userFunding", user: address, startTime });

[
  {
    "time": 1753660800000,
    "hash": "0x...",
    "delta": {
      "type": "funding",
      "coin": "BTC",
      "usdc": "-0.42",
      "szi": "0.12",
      "fundingRate": "0.0000125"
    }
  }
]

function deriveFunding(updates) {
  const asc = [...updates].sort((a, b) => a.time - b.time);
  const series = [];
  let net = 0;

  for (const u of asc) {
    net += Number(u.delta.usdc); // + received, − paid
    series.push({ time: u.time, value: net });
  }

  return { series, net };
}

const candles = await info({
  type: "candleSnapshot",
  req: { coin: "BTC", interval: "1h", startTime, endTime: Date.now() },
});

[
  {
    "t": 1753657200000,
    "T": 1753660799999,
    "s": "BTC",
    "i": "1h",
    "o": "62010.0",
    "c": "62150.0",
    "h": "62300.0",
    "l": "61890.0",
    "v": "142.85",
    "n": 3218
  }
]

function intervalForWindow(days) {
  return days <= 7 ? "1h" : days <= 30 ? "4h" : "1d";
}

async function loadPnl(address, days) {
  const startTime = Date.now() - days * 24 * 60 * 60 * 1000;

  const [fills, funding] = await Promise.all([
    info({ type: "userFillsByTime", user: address, startTime }),
    info({ type: "userFunding", user: address, startTime }),
  ]);

  const pnl = derivePnl(fills);
  const fundingDerivation = deriveFunding(funding);

  return {
    ...pnl,
    funding: fundingDerivation,
    net: pnl.realizedPnl + fundingDerivation.net,
  };
}