@ebowwa/quant-rust 0.1.0

package/src/index.ts

@@ -0,0 +1,1073 @@
+/**
+ * Bun FFI wrapper for quant-rust
+ *
+ * This module provides TypeScript bindings for the Rust quant library
+ * using Bun's FFI capabilities.
+ *
+ * @packageDocumentation
+ */
+
+import { dlopen, FFIType, ptr } from "bun:ffi";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+
+// Import types - re-exported at the end
+import type {
+  OHLCV,
+  AMMState,
+  AMMCostResult,
+  AMMPriceImpactResult,
+  LMSRState,
+  LMSRPriceResult,
+  KellyResult,
+  ArbitrageResult,
+  OddsConversion,
+  VaRResult,
+  DrawdownResult,
+  SharpeResult,
+} from "../types/index.js";
+
+// Get the path to the compiled library
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Get the path to the native library based on platform
+ */
+function getNativeLibPath(): string {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  // Map platform/arch to library name
+  const libName = (() => {
+    switch (platform) {
+      case "darwin":
+        return "libquant_rust.dylib";
+      case "linux":
+        return "libquant_rust.so";
+      case "win32":
+        return "quant_rust.dll";
+      default:
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+  })();
+
+  // Try multiple paths in order
+  const possiblePaths = [
+    // Prebuilt binaries in native/ directory
+    join(__dirname, "..", "native", `${platform}-${arch}`, libName),
+    // Development build
+    join(__dirname, "..", "target", "release", libName),
+    // Relative from dist
+    join(__dirname, "..", "..", "target", "release", libName),
+    // Check multiple levels up
+    join(__dirname, "..", "..", "..", "target", "release", libName),
+  ];
+
+  for (const p of possiblePaths) {
+    if (existsSync(p)) {
+      return p;
+    }
+  }
+
+  throw new Error(
+    `Could not find quant_rust library for ${platform}-${arch}. ` +
+    `Please run 'cargo build --release' or ensure prebuilt binaries are in native/${platform}-${arch}/`
+  );
+}
+
+// Load the native library
+const libPath = getNativeLibPath();
+
+// Define FFI symbols for the native library
+const symbols = {
+  // Version
+  quant_version: {
+    returns: FFIType.cstring,
+    args: [],
+  },
+
+  // Error handling
+  quant_last_error: {
+    returns: FFIType.cstring,
+    args: [],
+  },
+  quant_clear_error: {
+    returns: FFIType.void,
+    args: [],
+  },
+
+  // OHLCV
+  quant_ohlcv_new: {
+    returns: FFIType.cstring,
+    args: [FFIType.i64, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.f64],
+  },
+
+  // AMM
+  quant_amm_new: {
+    returns: FFIType.cstring,
+    args: [FFIType.f64, FFIType.f64, FFIType.f64],
+  },
+  quant_amm_calculate_cost: {
+    returns: FFIType.cstring,
+    args: [FFIType.f64, FFIType.f64, FFIType.bool, FFIType.f64],
+  },
+  quant_amm_price_impact: {
+    returns: FFIType.cstring,
+    args: [FFIType.f64, FFIType.f64, FFIType.bool, FFIType.f64],
+  },
+
+  // LMSR
+  quant_lmsr_price: {
+    returns: FFIType.cstring,
+    args: [FFIType.f64, FFIType.f64, FFIType.f64],
+  },
+  quant_lmsr_cost: {
+    returns: FFIType.cstring,
+    args: [FFIType.f64, FFIType.f64, FFIType.f64, FFIType.bool, FFIType.f64],
+  },
+
+  // Kelly Criterion
+  quant_kelly_criterion: {
+    returns: FFIType.cstring,
+    args: [FFIType.f64, FFIType.f64, FFIType.f64],
+  },
+
+  // Arbitrage
+  quant_detect_arbitrage: {
+    returns: FFIType.cstring,
+    args: [FFIType.f64, FFIType.f64],
+  },
+
+  // Odds Conversion
+  quant_convert_odds: {
+    returns: FFIType.cstring,
+    args: [FFIType.f64, FFIType.i32],
+  },
+
+  // Statistics
+  quant_mean: {
+    returns: FFIType.f64,
+    args: [FFIType.ptr, FFIType.usize],
+  },
+  quant_std_dev: {
+    returns: FFIType.f64,
+    args: [FFIType.ptr, FFIType.usize],
+  },
+  quant_variance: {
+    returns: FFIType.f64,
+    args: [FFIType.ptr, FFIType.usize],
+  },
+  quant_correlation: {
+    returns: FFIType.f64,
+    args: [FFIType.ptr, FFIType.ptr, FFIType.usize],
+  },
+
+  // Memory management
+  quant_free_string: {
+    returns: FFIType.void,
+    args: [FFIType.ptr],
+  },
+};
+
+// Load the library
+const lib = dlopen(libPath, symbols);
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Parse a JSON string response from the native library
+ * @internal
+ */
+function parseJsonResponse<T>(response: string | null): T {
+  if (!response) {
+    const error = lib.symbols.quant_last_error() as string;
+    throw new Error(error || "Unknown error from quant-rust");
+  }
+  try {
+    return JSON.parse(response) as T;
+  } catch (e) {
+    throw new Error(`Failed to parse JSON response: ${response}`);
+  }
+}
+
+/**
+ * Create a Float64Array pointer for FFI calls
+ * @internal
+ */
+function createFloat64Ptr(data: number[]): { buffer: Float64Array; ptr: number } {
+  const buffer = new Float64Array(data);
+  return { buffer, ptr: ptr(buffer) };
+}
+
+// ============================================================================
+// Library Info
+// ============================================================================
+
+/**
+ * Get the library version
+ */
+export function getVersion(): string {
+  return lib.symbols.quant_version() as string;
+}
+
+/**
+ * Clear the last error
+ */
+export function clearError(): void {
+  lib.symbols.quant_clear_error();
+}
+
+/**
+ * Get the path to the loaded native library
+ */
+export function getLibraryPath(): string {
+  return libPath;
+}
+
+// ============================================================================
+// OHLCV Functions
+// ============================================================================
+
+/**
+ * Create an OHLCV candlestick data structure
+ *
+ * @param timestamp - Unix timestamp in milliseconds
+ * @param open - Opening price
+ * @param high - High price
+ * @param low - Low price
+ * @param close - Closing price
+ * @param volume - Volume
+ * @returns OHLCV object
+ */
+export function createOHLCV(
+  timestamp: number,
+  open: number,
+  high: number,
+  low: number,
+  close: number,
+  volume: number
+): OHLCV {
+  const response = lib.symbols.quant_ohlcv_new(
+    BigInt(timestamp),
+    open,
+    high,
+    low,
+    close,
+    volume
+  ) as string;
+  return parseJsonResponse(response);
+}
+
+// ============================================================================
+// AMM Functions (Automated Market Maker)
+// ============================================================================
+
+/**
+ * Create an AMM state for constant-product AMMs
+ *
+ * @param poolYes - YES pool reserves
+ * @param poolNo - NO pool reserves
+ * @param fee - Fee as decimal (e.g., 0.003 for 0.3%)
+ * @returns AMMState object
+ */
+export function createAMM(poolYes: number, poolNo: number, fee: number): AMMState {
+  const response = lib.symbols.quant_amm_new(poolYes, poolNo, fee) as string;
+  return parseJsonResponse(response);
+}
+
+/**
+ * Calculate the cost to buy shares from a constant-product AMM
+ *
+ * Uses the formula: cost = new_pool_no - pool_no where new_pool_no = k / (pool_yes + shares)
+ *
+ * @param poolYes - Current YES pool reserves
+ * @param poolNo - Current NO pool reserves
+ * @param outcome - Whether to buy 'yes' or 'no' shares
+ * @param shares - Number of shares to buy
+ * @returns Cost in currency units (always positive, number for API compatibility)
+ */
+export function ammCalculateCost(
+  poolYes: number,
+  poolNo: number,
+  outcome: 'yes' | 'no' | boolean,
+  shares: number
+): number {
+  // Convert string outcome to boolean for FFI
+  const buyYes = typeof outcome === 'string' ? outcome === 'yes' : outcome;
+  const response = lib.symbols.quant_amm_calculate_cost(
+    poolYes,
+    poolNo,
+    buyYes,
+    shares
+  ) as string;
+  const result = parseJsonResponse<AMMCostResult>(response);
+  // Return absolute cost value for API compatibility with @ebowwa/quant
+  // (Rust returns negative values for the pool delta, we want positive cost)
+  return Math.abs(result.cost);
+}
+
+/**
+ * Calculate the cost to buy shares from a constant-product AMM (full result)
+ *
+ * @param poolYes - Current YES pool reserves
+ * @param poolNo - Current NO pool reserves
+ * @param outcome - Whether to buy 'yes' or 'no' shares
+ * @param shares - Number of shares to buy
+ * @returns Full cost calculation result with cost and avg_price (always positive)
+ */
+export function ammCalculateCostFull(
+  poolYes: number,
+  poolNo: number,
+  outcome: 'yes' | 'no' | boolean,
+  shares: number
+): AMMCostResult {
+  const buyYes = typeof outcome === 'string' ? outcome === 'yes' : outcome;
+  const response = lib.symbols.quant_amm_calculate_cost(
+    poolYes,
+    poolNo,
+    buyYes,
+    shares
+  ) as string;
+  const result = parseJsonResponse<AMMCostResult>(response);
+  // Return absolute values for cost and avg_price
+  return {
+    cost: Math.abs(result.cost),
+    avg_price: Math.abs(result.avg_price)
+  };
+}
+
+/**
+ * Calculate the price impact for a trade on a constant-product AMM
+ *
+ * @param poolYes - Current YES pool reserves
+ * @param poolNo - Current NO pool reserves
+ * @param outcome - Whether to buy 'yes' or 'no' shares
+ * @param shares - Number of shares to buy
+ * @returns Price impact analysis
+ */
+export function ammPriceImpact(
+  poolYes: number,
+  poolNo: number,
+  outcome: 'yes' | 'no' | boolean,
+  shares: number
+): AMMPriceImpactResult {
+  const buyYes = typeof outcome === 'string' ? outcome === 'yes' : outcome;
+  const response = lib.symbols.quant_amm_price_impact(
+    poolYes,
+    poolNo,
+    buyYes,
+    shares
+  ) as string;
+  return parseJsonResponse(response);
+}
+
+// Convenience aliases matching @ebowwa/quant API
+export const amm_buy_cost = ammCalculateCost;
+export const amm_calculate_cost = ammCalculateCost;
+export const amm_price_impact = ammPriceImpact;
+
+// ============================================================================
+// LMSR Functions (Logarithmic Market Scoring Rule)
+// ============================================================================
+
+/**
+ * Calculate LMSR prices for a prediction market
+ *
+ * Uses the LMSR formula: price_yes = exp(q_yes/b) / (exp(q_yes/b) + exp(q_no/b))
+ *
+ * @param yesShares - YES shares outstanding
+ * @param noShares - NO shares outstanding
+ * @param b - Liquidity parameter (controls price sensitivity)
+ * @returns LMSR price result with yes_price and no_price
+ */
+export function lmsrPrice(
+  yesShares: number,
+  noShares: number,
+  b: number
+): LMSRPriceResult {
+  const response = lib.symbols.quant_lmsr_price(yesShares, noShares, b) as string;
+  return parseJsonResponse(response);
+}
+
+/**
+ * Calculate the cost to buy shares using LMSR
+ *
+ * Uses the LMSR cost formula: C(q') - C(q) = b * ln(sum(exp(q'_i/b))) - b * ln(sum(exp(q_i/b)))
+ *
+ * @param yesShares - Current YES shares outstanding
+ * @param noShares - Current NO shares outstanding
+ * @param b - Liquidity parameter
+ * @param outcome - Whether to buy 'yes' or 'no' shares (or boolean)
+ * @param shares - Number of shares to buy
+ * @returns Cost calculation result
+ */
+export function lmsrCost(
+  yesShares: number,
+  noShares: number,
+  b: number,
+  outcome: 'yes' | 'no' | boolean,
+  shares: number
+): AMMCostResult {
+  const buyYes = typeof outcome === 'string' ? outcome === 'yes' : outcome;
+  const response = lib.symbols.quant_lmsr_cost(
+    yesShares,
+    noShares,
+    b,
+    buyYes,
+    shares
+  ) as string;
+  return parseJsonResponse(response);
+}
+
+/**
+ * Calculate LMSR price and cost (unified function)
+ *
+ * @param yesShares - Current YES shares outstanding
+ * @param noShares - Current NO shares outstanding
+ * @param liquidityParam - Liquidity parameter (b)
+ * @param operation - "price" or "cost"
+ * @param outcome - "yes" or "no"
+ * @param sharesToBuy - Number of shares (only for cost operation)
+ * @returns Price or cost result
+ */
+export function lmsrCalculate(
+  yesShares: number,
+  noShares: number,
+  liquidityParam: number,
+  operation: "price" | "cost",
+  outcome: "yes" | "no",
+  sharesToBuy?: number
+): LMSRPriceResult | AMMCostResult {
+  if (operation === "price") {
+    return lmsrPrice(yesShares, noShares, liquidityParam);
+  } else {
+    if (sharesToBuy === undefined) {
+      throw new Error("sharesToBuy is required for cost operation");
+    }
+    return lmsrCost(yesShares, noShares, liquidityParam, outcome === "yes", sharesToBuy);
+  }
+}
+
+// ============================================================================
+// Kelly Criterion Functions
+// ============================================================================
+
+/**
+ * Calculate the Kelly criterion for optimal position sizing
+ *
+ * The Kelly criterion determines the optimal fraction of bankroll to bet
+ * based on your estimated probability vs the market price.
+ *
+ * @param yourProbability - Your estimated probability of winning (0-1)
+ * @param marketPrice - Current market price to buy shares (0-1)
+ * @param bankroll - Your total bankroll in currency units
+ * @returns Kelly criterion result with various bet sizes
+ */
+export function kellyCriterion(
+  yourProbability: number,
+  marketPrice: number,
+  bankroll: number
+): KellyResult {
+  const response = lib.symbols.quant_kelly_criterion(
+    yourProbability,
+    marketPrice,
+    bankroll
+  ) as string;
+  return parseJsonResponse(response);
+}
+
+// Alias matching @ebowwa/quant API
+export const kelly_criterion = kellyCriterion;
+
+// ============================================================================
+// Arbitrage Detection Functions
+// ============================================================================
+
+/**
+ * Detect arbitrage opportunities in prediction markets
+ *
+ * If yes_price + no_price < 1, there's an arbitrage opportunity.
+ *
+ * @param yesPrice - Current YES share price (0-1)
+ * @param noPrice - Current NO share price (0-1)
+ * @returns Arbitrage analysis with profit field for API compatibility
+ */
+export function detectArbitrage(yesPrice: number, noPrice: number): ArbitrageResult & { profit: number } {
+  const response = lib.symbols.quant_detect_arbitrage(yesPrice, noPrice) as string;
+  const result = parseJsonResponse<ArbitrageResult>(response);
+  // Add profit alias for API compatibility (same as profit_per_share)
+  return { ...result, profit: result.profit_per_share };
+}
+
+// Alias matching @ebowwa/quant API
+export const detect_arbitrage = detectArbitrage;
+
+// ============================================================================
+// Odds Conversion Functions
+// ============================================================================
+
+/** Odds input type */
+export type OddsType = "probability" | "decimal" | "american";
+
+/**
+ * Convert between probability, decimal odds, and American odds
+ *
+ * @param value - The value to convert
+ * @param fromType - The type of the input value
+ * @param toType - Optional target type (if specified, returns just that value)
+ * @returns Converted odds in all formats, or single value if toType specified
+ */
+export function convertOdds(value: number, fromType: OddsType, toType?: OddsType): OddsConversion | number {
+  const typeMap: Record<OddsType, number> = {
+    probability: 0,
+    decimal: 1,
+    american: 2,
+  };
+  const response = lib.symbols.quant_convert_odds(value, typeMap[fromType]) as string;
+  const result = parseJsonResponse<OddsConversion>(response);
+
+  // If toType is specified, return just that value for API compatibility
+  if (toType) {
+    switch (toType) {
+      case 'probability':
+        return result.probability;
+      case 'decimal':
+        return result.decimal_odds;
+      case 'american':
+        return result.american_odds;
+      default:
+        return result;
+    }
+  }
+
+  return result;
+}
+
+// Alias matching @ebowwa/quant API
+export const convert_odds = convertOdds;
+
+// ============================================================================
+// Statistical Functions
+// ============================================================================
+
+/**
+ * Calculate the mean (average) of an array of numbers
+ *
+ * @param data - Array of numbers
+ * @returns Mean value, or NaN if array is empty
+ */
+export function mean(data: number[]): number {
+  if (data.length === 0) return NaN;
+  const { buffer, ptr: dataPtr } = createFloat64Ptr(data);
+  return lib.symbols.quant_mean(dataPtr, data.length) as number;
+}
+
+/**
+ * Calculate the standard deviation of an array of numbers
+ *
+ * @param data - Array of numbers
+ * @returns Standard deviation, or NaN if array is empty
+ */
+export function stdDev(data: number[]): number {
+  if (data.length === 0) return NaN;
+  const { buffer, ptr: dataPtr } = createFloat64Ptr(data);
+  return lib.symbols.quant_std_dev(dataPtr, data.length) as number;
+}
+
+/**
+ * Calculate the variance of an array of numbers
+ *
+ * @param data - Array of numbers
+ * @returns Variance, or NaN if array is empty
+ */
+export function variance(data: number[]): number {
+  if (data.length === 0) return NaN;
+  const { buffer, ptr: dataPtr } = createFloat64Ptr(data);
+  return lib.symbols.quant_variance(dataPtr, data.length) as number;
+}
+
+/**
+ * Calculate the Pearson correlation coefficient between two arrays
+ *
+ * @param x - First array of numbers
+ * @param y - Second array of numbers
+ * @returns Correlation coefficient (-1 to 1), or NaN if arrays are invalid
+ */
+export function correlation(x: number[], y: number[]): number {
+  if (x.length === 0 || y.length === 0 || x.length !== y.length) return NaN;
+  const { buffer: bufferX, ptr: ptrX } = createFloat64Ptr(x);
+  const { buffer: bufferY, ptr: ptrY } = createFloat64Ptr(y);
+  return lib.symbols.quant_correlation(ptrX, ptrY, x.length) as number;
+}
+
+// Aliases matching @ebowwa/quant API
+export const std_dev = stdDev;
+
+// ============================================================================
+// Technical Indicators (TypeScript implementations for array-based operations)
+// ============================================================================
+
+/**
+ * Simple Moving Average (SMA)
+ *
+ * @param prices - Array of prices
+ * @param period - Number of periods to average
+ * @returns Array of SMA values
+ */
+export function sma(prices: number[], period: number): number[] {
+  if (prices.length < period || period <= 0) return [];
+
+  const result: number[] = [];
+  for (let i = period - 1; i < prices.length; i++) {
+    let sum = 0;
+    for (let j = i - period + 1; j <= i; j++) {
+      sum += prices[j];
+    }
+    result.push(sum / period);
+  }
+  return result;
+}
+
+/**
+ * Exponential Moving Average (EMA)
+ *
+ * @param prices - Array of prices
+ * @param period - EMA period
+ * @returns Array of EMA values
+ */
+export function ema(prices: number[], period: number): number[] {
+  if (prices.length < period || period <= 0) return [];
+
+  const multiplier = 2 / (period + 1);
+  const result: number[] = [];
+
+  // First EMA value is SMA
+  let prevEma = prices.slice(0, period).reduce((a, b) => a + b, 0) / period;
+  result.push(prevEma);
+
+  // Calculate EMA for remaining values
+  for (let i = period; i < prices.length; i++) {
+    const currentEma = (prices[i] - prevEma) * multiplier + prevEma;
+    result.push(currentEma);
+    prevEma = currentEma;
+  }
+
+  return result;
+}
+
+/**
+ * Relative Strength Index (RSI)
+ *
+ * @param prices - Array of prices
+ * @param period - RSI period (default: 14)
+ * @returns Array of RSI values (0-100)
+ */
+export function rsi(prices: number[], period: number = 14): number[] {
+  if (prices.length < period + 1 || period <= 0) return [];
+
+  const gains: number[] = [];
+  const losses: number[] = [];
+
+  // Calculate price changes
+  for (let i = 1; i < prices.length; i++) {
+    const change = prices[i] - prices[i - 1];
+    gains.push(change > 0 ? change : 0);
+    losses.push(change < 0 ? Math.abs(change) : 0);
+  }
+
+  // First average
+  let avgGain = gains.slice(0, period).reduce((a, b) => a + b, 0) / period;
+  let avgLoss = losses.slice(0, period).reduce((a, b) => a + b, 0) / period;
+
+  const result: number[] = [];
+
+  // First RSI
+  if (avgLoss === 0) {
+    result.push(100);
+  } else {
+    const rs = avgGain / avgLoss;
+    result.push(100 - 100 / (1 + rs));
+  }
+
+  // Subsequent values using smoothed average
+  for (let i = period; i < gains.length; i++) {
+    avgGain = (avgGain * (period - 1) + gains[i]) / period;
+    avgLoss = (avgLoss * (period - 1) + losses[i]) / period;
+
+    if (avgLoss === 0) {
+      result.push(100);
+    } else {
+      const rs = avgGain / avgLoss;
+      result.push(100 - 100 / (1 + rs));
+    }
+  }
+
+  return result;
+}
+
+/**
+ * MACD (Moving Average Convergence Divergence)
+ *
+ * @param prices - Array of prices
+ * @param fastPeriod - Fast EMA period (default: 12)
+ * @param slowPeriod - Slow EMA period (default: 26)
+ * @param signalPeriod - Signal line period (default: 9)
+ * @returns Object with macd, signal, and histogram arrays
+ */
+export function macd(
+  prices: number[],
+  fastPeriod: number = 12,
+  slowPeriod: number = 26,
+  signalPeriod: number = 9
+): { macd: number[]; signal: number[]; histogram: number[] } {
+  if (prices.length < slowPeriod) {
+    return { macd: [], signal: [], histogram: [] };
+  }
+
+  const fastEma = ema(prices, fastPeriod);
+  const slowEma = ema(prices, slowPeriod);
+
+  // Align arrays
+  const offset = slowPeriod - fastPeriod;
+  const macdLine: number[] = [];
+
+  for (let i = 0; i < slowEma.length; i++) {
+    if (i + offset < fastEma.length) {
+      macdLine.push(fastEma[i + offset] - slowEma[i]);
+    }
+  }
+
+  const signalLine = ema(macdLine, signalPeriod);
+
+  // Align histogram with signal
+  const signalOffset = signalPeriod - 1;
+  const histogram: number[] = [];
+
+  for (let i = 0; i < signalLine.length; i++) {
+    if (i + signalOffset < macdLine.length) {
+      histogram.push(macdLine[i + signalOffset] - signalLine[i]);
+    }
+  }
+
+  return {
+    macd: macdLine.slice(signalOffset, signalOffset + histogram.length),
+    signal: signalLine,
+    histogram,
+  };
+}
+
+// ============================================================================
+// Risk Management Functions (TypeScript implementations)
+// ============================================================================
+
+/**
+ * Calculate Value at Risk (VaR) and Expected Shortfall (CVaR)
+ *
+ * @param returns - Array of returns
+ * @param confidenceLevel - Confidence level (default: 0.95)
+ * @returns VaR result
+ */
+export function calculateVar(
+  returns: number[],
+  confidenceLevel: number = 0.95
+): VaRResult {
+  if (returns.length === 0) {
+    return { var: 0, cvar: 0, confidence_level: confidenceLevel };
+  }
+
+  const sorted = [...returns].sort((a, b) => a - b);
+  const index = Math.floor((1 - confidenceLevel) * returns.length);
+  const clampedIndex = Math.min(index, sorted.length - 1);
+
+  const varValue = -sorted[clampedIndex];
+
+  // CVaR is the average of returns below VaR
+  const tailReturns = sorted.slice(0, clampedIndex + 1);
+  const cvar = tailReturns.length > 0
+    ? -tailReturns.reduce((a, b) => a + b, 0) / tailReturns.length
+    : varValue;
+
+  return { var: varValue, cvar, confidence_level: confidenceLevel };
+}
+
+/**
+ * Calculate drawdown analysis from equity curve
+ *
+ * @param equityCurve - Array of equity values over time
+ * @returns Drawdown analysis result
+ */
+export function calculateDrawdown(equityCurve: number[]): DrawdownResult {
+  if (equityCurve.length < 2) {
+    return { max_drawdown: 0, max_duration: 0, current_drawdown: 0, recovery_factor: 0 };
+  }
+
+  let maxDrawdown = 0;
+  let maxDuration = 0;
+  let peak = equityCurve[0];
+  let lastPeakIdx = 0;
+
+  for (let i = 0; i < equityCurve.length; i++) {
+    const equity = equityCurve[i];
+    if (equity > peak) {
+      peak = equity;
+      lastPeakIdx = i;
+    } else {
+      const duration = i - lastPeakIdx;
+      const drawdown = (peak - equity) / peak;
+      if (drawdown > maxDrawdown) {
+        maxDrawdown = drawdown;
+        maxDuration = duration;
+      }
+    }
+  }
+
+  const currentDrawdown = peak > 0
+    ? (peak - equityCurve[equityCurve.length - 1]) / peak
+    : 0;
+
+  const totalReturn = equityCurve[0] > 0
+    ? (equityCurve[equityCurve.length - 1] - equityCurve[0]) / equityCurve[0]
+    : 0;
+
+  const recoveryFactor = maxDrawdown > 0 ? totalReturn / maxDrawdown : Infinity;
+
+  return {
+    max_drawdown: maxDrawdown,
+    max_duration: maxDuration,
+    current_drawdown: currentDrawdown,
+    recovery_factor: recoveryFactor,
+  };
+}
+
+/**
+ * Calculate Sharpe ratio
+ *
+ * @param returns - Array of returns
+ * @param riskFreeRate - Annual risk-free rate (default: 0.04)
+ * @param periodsPerYear - Trading periods per year (default: 252)
+ * @returns Annualized Sharpe ratio (number for API compatibility)
+ */
+export function calculateSharpeRatio(
+  returns: number[],
+  riskFreeRate: number = 0.04,
+  periodsPerYear: number = 252
+): number {
+  if (returns.length === 0) {
+    return 0;
+  }
+
+  const avgReturn = returns.reduce((a, b) => a + b, 0) / returns.length;
+  const stdDev = Math.sqrt(
+    returns.reduce((sum, r) => sum + Math.pow(r - avgReturn, 2), 0) / returns.length
+  );
+
+  if (stdDev === 0) {
+    return 0;
+  }
+
+  const excessReturn = avgReturn - riskFreeRate / periodsPerYear;
+  const sharpeRatio = excessReturn / stdDev;
+  const annualizedSharpe = sharpeRatio * Math.sqrt(periodsPerYear);
+
+  return annualizedSharpe;
+}
+
+/**
+ * Calculate Sharpe ratio with full result
+ *
+ * @param returns - Array of returns
+ * @param riskFreeRate - Annual risk-free rate (default: 0.04)
+ * @param periodsPerYear - Trading periods per year (default: 252)
+ * @returns Full Sharpe ratio result object
+ */
+export function calculateSharpeRatioFull(
+  returns: number[],
+  riskFreeRate: number = 0.04,
+  periodsPerYear: number = 252
+): SharpeResult {
+  if (returns.length === 0) {
+    return { sharpe_ratio: 0, annualized_sharpe: 0, risk_free_rate: riskFreeRate, avg_return: 0, std_dev: 0 };
+  }
+
+  const avgReturn = returns.reduce((a, b) => a + b, 0) / returns.length;
+  const stdDev = Math.sqrt(
+    returns.reduce((sum, r) => sum + Math.pow(r - avgReturn, 2), 0) / returns.length
+  );
+
+  if (stdDev === 0) {
+    return { sharpe_ratio: 0, annualized_sharpe: 0, risk_free_rate: riskFreeRate, avg_return: avgReturn, std_dev: 0 };
+  }
+
+  const excessReturn = avgReturn - riskFreeRate / periodsPerYear;
+  const sharpeRatio = excessReturn / stdDev;
+  const annualizedSharpe = sharpeRatio * Math.sqrt(periodsPerYear);
+
+  return {
+    sharpe_ratio: sharpeRatio,
+    annualized_sharpe: annualizedSharpe,
+    risk_free_rate: riskFreeRate,
+    avg_return: avgReturn,
+    std_dev: stdDev,
+  };
+}
+
+// Aliases matching @ebowwa/quant API
+export const calculate_var = calculateVar;
+export const calculate_drawdown = calculateDrawdown;
+export const calculate_sharpe_ratio = calculateSharpeRatio;
+export const sharpeRatio = calculateSharpeRatio;
+
+/**
+ * Calculate Sortino ratio (only penalizes downside volatility)
+ *
+ * @param returns - Array of returns
+ * @param riskFreeRate - Annual risk-free rate (default: 0.04)
+ * @param periodsPerYear - Trading periods per year (default: 252)
+ * @returns Sortino ratio
+ */
+export function calculateSortinoRatio(
+  returns: number[],
+  riskFreeRate: number = 0.04,
+  periodsPerYear: number = 252
+): number {
+  if (returns.length === 0) return 0;
+
+  const avgReturn = returns.reduce((a, b) => a + b, 0) / returns.length;
+  const target = riskFreeRate / periodsPerYear;
+
+  // Downside deviation
+  const downsideReturns = returns.filter(r => r < target);
+  const downsideVariance = downsideReturns.length > 0
+    ? downsideReturns.reduce((sum, r) => sum + Math.pow(r - target, 2), 0) / returns.length
+    : 0;
+
+  const downsideDev = Math.sqrt(downsideVariance);
+
+  if (downsideDev === 0) return Infinity;
+
+  const excessReturn = avgReturn - target;
+  return (excessReturn / downsideDev) * Math.sqrt(periodsPerYear);
+}
+
+/**
+ * Calculate beta and alpha against a benchmark
+ *
+ * @param assetReturns - Array of asset returns
+ * @param benchmarkReturns - Array of benchmark returns
+ * @returns Object with beta and alpha values
+ */
+export function calculateBetaAlpha(
+  assetReturns: number[],
+  benchmarkReturns: number[]
+): { beta: number; alpha: number } {
+  if (
+    assetReturns.length === 0 ||
+    benchmarkReturns.length === 0 ||
+    assetReturns.length !== benchmarkReturns.length
+  ) {
+    return { beta: 0, alpha: 0 };
+  }
+
+  const n = assetReturns.length;
+  const avgAsset = assetReturns.reduce((a, b) => a + b, 0) / n;
+  const avgBench = benchmarkReturns.reduce((a, b) => a + b, 0) / n;
+
+  // Covariance
+  const cov = assetReturns.reduce(
+    (sum, a, i) => sum + (a - avgAsset) * (benchmarkReturns[i] - avgBench),
+    0
+  ) / n;
+
+  // Benchmark variance
+  const varBench = benchmarkReturns.reduce(
+    (sum, r) => sum + Math.pow(r - avgBench, 2),
+    0
+  ) / n;
+
+  if (varBench === 0) return { beta: 0, alpha: 0 };
+
+  const beta = cov / varBench;
+  const alpha = avgAsset - beta * avgBench;
+
+  return { beta, alpha };
+}
+
+// Aliases matching @ebowwa/quant API
+export const calculate_sortino_ratio = calculateSortinoRatio;
+export const calculate_beta_alpha = calculateBetaAlpha;
+
+// ============================================================================
+// Re-export Types
+// ============================================================================
+
+export * from "../types/index.js";
+
+// ============================================================================
+// Default Export
+// ============================================================================
+
+export default {
+  // Library info
+  getVersion,
+  clearError,
+  getLibraryPath,
+
+  // OHLCV
+  createOHLCV,
+
+  // AMM
+  createAMM,
+  ammCalculateCost,
+  ammCalculateCostFull,
+  ammPriceImpact,
+  amm_buy_cost,
+  amm_calculate_cost,
+  amm_price_impact,
+
+  // LMSR
+  lmsrPrice,
+  lmsrCost,
+  lmsrCalculate,
+
+  // Kelly
+  kellyCriterion,
+  kelly_criterion,
+
+  // Arbitrage
+  detectArbitrage,
+  detect_arbitrage,
+
+  // Odds
+  convertOdds,
+  convert_odds,
+
+  // Statistics
+  mean,
+  stdDev,
+  std_dev,
+  variance,
+  correlation,
+
+  // Indicators
+  sma,
+  ema,
+  rsi,
+  macd,
+
+  // Risk
+  calculateVar,
+  calculate_var,
+  calculateDrawdown,
+  calculate_drawdown,
+  calculateSharpeRatio,
+  calculateSharpeRatioFull,
+  calculate_sharpe_ratio,
+  sharpeRatio,
+  calculateSortinoRatio,
+  calculate_sortino_ratio,
+  calculateBetaAlpha,
+  calculate_beta_alpha,
+};