PnL analysis.

// Module 13, Sharpe / Sortino / Max Drawdown
// Source: GET /portfolio/pnl-chart?timeframe=30d
// Response: { timeframe, data: [{timestamp (ms), value (USD)}],
//             currentValue, previousValue, percentChange, current }

import { createHmac } from 'node:crypto';

const BASE = 'https://api.limitless.exchange';
const PERIODS_PER_YEAR = 365;

function signedHeaders(method: string, pathWithQuery: string, body = ''): Record<string, string> {
  const ts  = new Date().toISOString();
  const msg = `${ts}\n${method}\n${pathWithQuery}\n${body}`;
  const sig = createHmac('sha256', Buffer.from(process.env.LMTS_TOKEN_SECRET!, 'base64'))
    .update(msg)
    .digest('base64');
  return {
    'lmts-api-key':   process.env.LMTS_TOKEN_ID!,
    'lmts-timestamp': ts,
    'lmts-signature': sig,
  };
}

type PnLPoint    = { timestamp: number; value: number };
type PnLResponse = {
  timeframe:     string;
  data:          PnLPoint[];
  currentValue:  number;
  previousValue: number;
  percentChange: number;
  current:       object | null;
};

async function fetchPnl(timeframe = '30d'): Promise<PnLResponse> {
  const path = `/portfolio/pnl-chart?timeframe=${timeframe}`;
  const res  = await fetch(`${BASE}${path}`, {
    headers: signedHeaders('GET', path),
  });
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json();
}

const mean   = (xs: number[]) => xs.reduce((a, b) => a + b, 0) / xs.length;
const stddev = (xs: number[]) => {
  const m = mean(xs);
  return Math.sqrt(xs.reduce((a, b) => a + (b - m) ** 2, 0) / xs.length);
};

function sharpe(returns: number[], rf = 0): number {
  const excess = returns.map(r => r - rf / PERIODS_PER_YEAR);
  return (mean(excess) / stddev(excess)) * Math.sqrt(PERIODS_PER_YEAR);
}

function sortino(returns: number[], rf = 0): number {
  const excess   = returns.map(r => r - rf / PERIODS_PER_YEAR);
  const downside = excess.filter(r => r < 0);
  const dd       = Math.sqrt(downside.reduce((a, r) => a + r * r, 0) / returns.length);
  return (mean(excess) / dd) * Math.sqrt(PERIODS_PER_YEAR);
}

function maxDrawdown(equity: number[]): number {
  let peak = equity[0], mdd = 0;
  for (const v of equity) {
    if (v > peak) peak = v;
    mdd = Math.min(mdd, (v - peak) / peak);
  }
  return mdd;
}

(async () => {
  const pnl = await fetchPnl('30d');

  // Turn cumulative realised PnL (USD) into an equity curve and per-period returns.
  const equity  = pnl.data.map(p => 1 + p.value / 1_000); // normalise to base 1.0
  const returns = equity.slice(1).map((v, i) => v / equity[i] - 1);

  console.log('Samples:', pnl.data.length);
  console.log('Sharpe: ', sharpe(returns).toFixed(2));
  console.log('Sortino:', sortino(returns).toFixed(2));
  console.log('Max DD: ', (maxDrawdown(equity) * 100).toFixed(2), '%');
})();

# Module 13, Sharpe / Sortino / Max Drawdown
# Source: GET /portfolio/pnl-chart?timeframe=30d
# Response: { timeframe, data: [{timestamp (ms), value (USD)}],
#             currentValue, previousValue, percentChange, current }

import asyncio
import base64
import datetime
import hashlib
import hmac
import os
import numpy as np
import httpx

BASE = "https://api.limitless.exchange"
PERIODS_PER_YEAR = 365


def signed_headers(method: str, path_with_query: str, body: str = "") -> dict[str, str]:
    now = datetime.datetime.now(datetime.timezone.utc)
    ts  = now.strftime("%Y-%m-%dT%H:%M:%S.") + f"{now.microsecond // 1000:03d}Z"
    msg = f"{ts}\n{method}\n{path_with_query}\n{body}"
    sig = base64.b64encode(
        hmac.new(base64.b64decode(os.environ["LMTS_TOKEN_SECRET"]),
                 msg.encode("utf-8"), hashlib.sha256).digest()
    ).decode("ascii")
    return {
        "lmts-api-key":   os.environ["LMTS_TOKEN_ID"],
        "lmts-timestamp": ts,
        "lmts-signature": sig,
    }


async def fetch_pnl(timeframe: str = "30d") -> dict:
    path = f"/portfolio/pnl-chart?timeframe={timeframe}"
    async with httpx.AsyncClient(timeout=10.0) as client:
        resp = await client.get(
            f"{BASE}{path}", headers=signed_headers("GET", path)
        )
        resp.raise_for_status()
        return resp.json()


def sharpe(returns: np.ndarray, rf: float = 0.0) -> float:
    excess = returns - rf / PERIODS_PER_YEAR
    return float(excess.mean() / excess.std(ddof=0) * np.sqrt(PERIODS_PER_YEAR))


def sortino(returns: np.ndarray, rf: float = 0.0) -> float:
    excess   = returns - rf / PERIODS_PER_YEAR
    downside = excess[excess < 0]
    dd       = np.sqrt(np.sum(downside ** 2) / len(returns))
    return float(excess.mean() / dd * np.sqrt(PERIODS_PER_YEAR))


def max_drawdown(equity: np.ndarray) -> float:
    running_max = np.maximum.accumulate(equity)
    return float(((equity - running_max) / running_max).min())


async def main() -> None:
    pnl    = await fetch_pnl("30d")
    values = np.array([p["value"] for p in pnl["data"]], dtype=float)

    # Cumulative realised PnL (USD) -> base-1 equity curve -> per-period returns.
    equity  = 1.0 + values / 1_000.0
    returns = np.diff(equity) / equity[:-1]

    print(f"Samples: {len(pnl['data'])}")
    print(f"Sharpe:  {sharpe(returns):.2f}")
    print(f"Sortino: {sortino(returns):.2f}")
    print(f"Max DD:  {max_drawdown(equity) * 100:.2f} %")


if __name__ == "__main__":
    asyncio.run(main())

// Module 13, Sharpe / Sortino / Max Drawdown
// Source: GET /portfolio/pnl-chart?timeframe=30d
// Response: { timeframe, data: [{timestamp (ms), value (USD)}],
//             currentValue, previousValue, percentChange, current }
// Uses stdlib math only, swap for gonum/stat on large series.

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/base64"
    "encoding/json"
    "fmt"
    "log"
    "math"
    "net/http"
    "os"
    "time"
)

const (
    base           = "https://api.limitless.exchange"
    periodsPerYear = 365.0
)

func signedHeaders(method, pathWithQuery, body string) map[string]string {
    ts := time.Now().UTC().Format("2006-01-02T15:04:05.000Z")
    msg := ts + "\n" + method + "\n" + pathWithQuery + "\n" + body
    secret, _ := base64.StdEncoding.DecodeString(os.Getenv("LMTS_TOKEN_SECRET"))
    mac := hmac.New(sha256.New, secret)
    mac.Write([]byte(msg))
    sig := base64.StdEncoding.EncodeToString(mac.Sum(nil))
    return map[string]string{
        "lmts-api-key":   os.Getenv("LMTS_TOKEN_ID"),
        "lmts-timestamp": ts,
        "lmts-signature": sig,
    }
}

type PnLPoint struct {
    Timestamp int64   `json:"timestamp"` // ms
    Value     float64 `json:"value"`     // USD
}

type PnLResponse struct {
    Timeframe     string     `json:"timeframe"`
    Data          []PnLPoint `json:"data"`
    CurrentValue  float64    `json:"currentValue"`
    PreviousValue float64    `json:"previousValue"`
    PercentChange float64    `json:"percentChange"`
}

func fetchPnl(timeframe string) (*PnLResponse, error) {
    path := fmt.Sprintf("/portfolio/pnl-chart?timeframe=%s", timeframe)
    req, err := http.NewRequest(http.MethodGet, base+path, nil)
    if err != nil {
        return nil, err
    }
    for k, v := range signedHeaders("GET", path, "") {
        req.Header.Set(k, v)
    }

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    var out PnLResponse
    if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
        return nil, err
    }
    return &out, nil
}

func mean(xs []float64) float64 {
    var s float64
    for _, v := range xs {
        s += v
    }
    return s / float64(len(xs))
}

func stddev(xs []float64) float64 {
    m := mean(xs)
    var v float64
    for _, x := range xs {
        v += (x - m) * (x - m)
    }
    return math.Sqrt(v / float64(len(xs)))
}

func sharpe(returns []float64) float64 {
    return (mean(returns) / stddev(returns)) * math.Sqrt(periodsPerYear)
}

func sortino(returns []float64) float64 {
    var dd float64
    for _, r := range returns {
        if r < 0 {
            dd += r * r
        }
    }
    ddStd := math.Sqrt(dd / float64(len(returns)))
    return (mean(returns) / ddStd) * math.Sqrt(periodsPerYear)
}

func maxDrawdown(equity []float64) float64 {
    peak, mdd := equity[0], 0.0
    for _, v := range equity {
        if v > peak {
            peak = v
        }
        if d := (v - peak) / peak; d < mdd {
            mdd = d
        }
    }
    return mdd
}

func main() {
    pnl, err := fetchPnl("30d")
    if err != nil {
        log.Fatal(err)
    }

    // Cumulative realised PnL (USD) -> base-1 equity -> per-period returns.
    equity := make([]float64, len(pnl.Data))
    for i, p := range pnl.Data {
        equity[i] = 1.0 + p.Value/1_000.0
    }
    returns := make([]float64, 0, len(equity)-1)
    for i := 1; i < len(equity); i++ {
        returns = append(returns, equity[i]/equity[i-1]-1)
    }

    fmt.Printf("Samples: %d\n", len(pnl.Data))
    fmt.Printf("Sharpe:  %.2f\n", sharpe(returns))
    fmt.Printf("Sortino: %.2f\n", sortino(returns))
    fmt.Printf("Max DD:  %.2f %%\n", maxDrawdown(equity)*100)
}