@ebowwa/quant-rust 0.1.0

package/dist/index.js

@@ -0,0 +1,576 @@
+// @bun
+// src/index.ts
+import { dlopen, FFIType, ptr } from "bun:ffi";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+
+// types/index.ts
+var Signal;
+((Signal2) => {
+  Signal2[Signal2["StrongBuy"] = 2] = "StrongBuy";
+  Signal2[Signal2["Buy"] = 1] = "Buy";
+  Signal2[Signal2["Neutral"] = 0] = "Neutral";
+  Signal2[Signal2["Sell"] = -1] = "Sell";
+  Signal2[Signal2["StrongSell"] = -2] = "StrongSell";
+})(Signal ||= {});
+var CandlePattern;
+((CandlePattern2) => {
+  CandlePattern2["Doji"] = "Doji";
+  CandlePattern2["Hammer"] = "Hammer";
+  CandlePattern2["InvertedHammer"] = "InvertedHammer";
+  CandlePattern2["BullishEngulfing"] = "BullishEngulfing";
+  CandlePattern2["BearishEngulfing"] = "BearishEngulfing";
+  CandlePattern2["MorningStar"] = "MorningStar";
+  CandlePattern2["EveningStar"] = "EveningStar";
+  CandlePattern2["ThreeWhiteSoldiers"] = "ThreeWhiteSoldiers";
+  CandlePattern2["ThreeBlackCrows"] = "ThreeBlackCrows";
+  CandlePattern2["ShootingStar"] = "ShootingStar";
+  CandlePattern2["HangingMan"] = "HangingMan";
+})(CandlePattern ||= {});
+function calculateEdge(yourProbability, marketPrice) {
+  const edge = yourProbability - marketPrice;
+  return {
+    edge,
+    has_edge: edge > 0,
+    edge_percent: edge * 100
+  };
+}
+function positionSizeFixedFractional(capital, riskPercent, entryPrice, stopLoss) {
+  const riskAmount = capital * riskPercent;
+  const riskPerShare = Math.abs(entryPrice - stopLoss);
+  const shares = riskPerShare > 0 ? Math.floor(riskAmount / riskPerShare) : 0;
+  const positionSize = shares * entryPrice;
+  return {
+    position_size: positionSize,
+    shares,
+    risk_amount: riskAmount,
+    entry_price: entryPrice,
+    stop_loss: stopLoss
+  };
+}
+
+// src/index.ts
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+function getNativeLibPath() {
+  const platform = process.platform;
+  const arch = process.arch;
+  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}`);
+    }
+  })();
+  const possiblePaths = [
+    join(__dirname2, "..", "native", `${platform}-${arch}`, libName),
+    join(__dirname2, "..", "target", "release", libName),
+    join(__dirname2, "..", "..", "target", "release", libName),
+    join(__dirname2, "..", "..", "..", "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}/`);
+}
+var libPath = getNativeLibPath();
+var symbols = {
+  quant_version: {
+    returns: FFIType.cstring,
+    args: []
+  },
+  quant_last_error: {
+    returns: FFIType.cstring,
+    args: []
+  },
+  quant_clear_error: {
+    returns: FFIType.void,
+    args: []
+  },
+  quant_ohlcv_new: {
+    returns: FFIType.cstring,
+    args: [FFIType.i64, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.f64]
+  },
+  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]
+  },
+  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]
+  },
+  quant_kelly_criterion: {
+    returns: FFIType.cstring,
+    args: [FFIType.f64, FFIType.f64, FFIType.f64]
+  },
+  quant_detect_arbitrage: {
+    returns: FFIType.cstring,
+    args: [FFIType.f64, FFIType.f64]
+  },
+  quant_convert_odds: {
+    returns: FFIType.cstring,
+    args: [FFIType.f64, FFIType.i32]
+  },
+  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]
+  },
+  quant_free_string: {
+    returns: FFIType.void,
+    args: [FFIType.ptr]
+  }
+};
+var lib = dlopen(libPath, symbols);
+function parseJsonResponse(response) {
+  if (!response) {
+    const error = lib.symbols.quant_last_error();
+    throw new Error(error || "Unknown error from quant-rust");
+  }
+  try {
+    return JSON.parse(response);
+  } catch (e) {
+    throw new Error(`Failed to parse JSON response: ${response}`);
+  }
+}
+function createFloat64Ptr(data) {
+  const buffer = new Float64Array(data);
+  return { buffer, ptr: ptr(buffer) };
+}
+function getVersion() {
+  return lib.symbols.quant_version();
+}
+function clearError() {
+  lib.symbols.quant_clear_error();
+}
+function getLibraryPath() {
+  return libPath;
+}
+function createOHLCV(timestamp, open, high, low, close, volume) {
+  const response = lib.symbols.quant_ohlcv_new(BigInt(timestamp), open, high, low, close, volume);
+  return parseJsonResponse(response);
+}
+function createAMM(poolYes, poolNo, fee) {
+  const response = lib.symbols.quant_amm_new(poolYes, poolNo, fee);
+  return parseJsonResponse(response);
+}
+function ammCalculateCost(poolYes, poolNo, outcome, shares) {
+  const buyYes = typeof outcome === "string" ? outcome === "yes" : outcome;
+  const response = lib.symbols.quant_amm_calculate_cost(poolYes, poolNo, buyYes, shares);
+  const result = parseJsonResponse(response);
+  return Math.abs(result.cost);
+}
+function ammCalculateCostFull(poolYes, poolNo, outcome, shares) {
+  const buyYes = typeof outcome === "string" ? outcome === "yes" : outcome;
+  const response = lib.symbols.quant_amm_calculate_cost(poolYes, poolNo, buyYes, shares);
+  const result = parseJsonResponse(response);
+  return {
+    cost: Math.abs(result.cost),
+    avg_price: Math.abs(result.avg_price)
+  };
+}
+function ammPriceImpact(poolYes, poolNo, outcome, shares) {
+  const buyYes = typeof outcome === "string" ? outcome === "yes" : outcome;
+  const response = lib.symbols.quant_amm_price_impact(poolYes, poolNo, buyYes, shares);
+  return parseJsonResponse(response);
+}
+var amm_buy_cost = ammCalculateCost;
+var amm_calculate_cost = ammCalculateCost;
+var amm_price_impact = ammPriceImpact;
+function lmsrPrice(yesShares, noShares, b) {
+  const response = lib.symbols.quant_lmsr_price(yesShares, noShares, b);
+  return parseJsonResponse(response);
+}
+function lmsrCost(yesShares, noShares, b, outcome, shares) {
+  const buyYes = typeof outcome === "string" ? outcome === "yes" : outcome;
+  const response = lib.symbols.quant_lmsr_cost(yesShares, noShares, b, buyYes, shares);
+  return parseJsonResponse(response);
+}
+function lmsrCalculate(yesShares, noShares, liquidityParam, operation, outcome, sharesToBuy) {
+  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);
+  }
+}
+function kellyCriterion(yourProbability, marketPrice, bankroll) {
+  const response = lib.symbols.quant_kelly_criterion(yourProbability, marketPrice, bankroll);
+  return parseJsonResponse(response);
+}
+var kelly_criterion = kellyCriterion;
+function detectArbitrage(yesPrice, noPrice) {
+  const response = lib.symbols.quant_detect_arbitrage(yesPrice, noPrice);
+  const result = parseJsonResponse(response);
+  return { ...result, profit: result.profit_per_share };
+}
+var detect_arbitrage = detectArbitrage;
+function convertOdds(value, fromType, toType) {
+  const typeMap = {
+    probability: 0,
+    decimal: 1,
+    american: 2
+  };
+  const response = lib.symbols.quant_convert_odds(value, typeMap[fromType]);
+  const result = parseJsonResponse(response);
+  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;
+}
+var convert_odds = convertOdds;
+function mean(data) {
+  if (data.length === 0)
+    return NaN;
+  const { buffer, ptr: dataPtr } = createFloat64Ptr(data);
+  return lib.symbols.quant_mean(dataPtr, data.length);
+}
+function stdDev(data) {
+  if (data.length === 0)
+    return NaN;
+  const { buffer, ptr: dataPtr } = createFloat64Ptr(data);
+  return lib.symbols.quant_std_dev(dataPtr, data.length);
+}
+function variance(data) {
+  if (data.length === 0)
+    return NaN;
+  const { buffer, ptr: dataPtr } = createFloat64Ptr(data);
+  return lib.symbols.quant_variance(dataPtr, data.length);
+}
+function correlation(x, y) {
+  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);
+}
+var std_dev = stdDev;
+function sma(prices, period) {
+  if (prices.length < period || period <= 0)
+    return [];
+  const result = [];
+  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;
+}
+function ema(prices, period) {
+  if (prices.length < period || period <= 0)
+    return [];
+  const multiplier = 2 / (period + 1);
+  const result = [];
+  let prevEma = prices.slice(0, period).reduce((a, b) => a + b, 0) / period;
+  result.push(prevEma);
+  for (let i = period;i < prices.length; i++) {
+    const currentEma = (prices[i] - prevEma) * multiplier + prevEma;
+    result.push(currentEma);
+    prevEma = currentEma;
+  }
+  return result;
+}
+function rsi(prices, period = 14) {
+  if (prices.length < period + 1 || period <= 0)
+    return [];
+  const gains = [];
+  const losses = [];
+  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);
+  }
+  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 = [];
+  if (avgLoss === 0) {
+    result.push(100);
+  } else {
+    const rs = avgGain / avgLoss;
+    result.push(100 - 100 / (1 + rs));
+  }
+  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;
+}
+function macd(prices, fastPeriod = 12, slowPeriod = 26, signalPeriod = 9) {
+  if (prices.length < slowPeriod) {
+    return { macd: [], signal: [], histogram: [] };
+  }
+  const fastEma = ema(prices, fastPeriod);
+  const slowEma = ema(prices, slowPeriod);
+  const offset = slowPeriod - fastPeriod;
+  const macdLine = [];
+  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);
+  const signalOffset = signalPeriod - 1;
+  const histogram = [];
+  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
+  };
+}
+function calculateVar(returns, confidenceLevel = 0.95) {
+  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];
+  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 };
+}
+function calculateDrawdown(equityCurve) {
+  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
+  };
+}
+function calculateSharpeRatio(returns, riskFreeRate = 0.04, periodsPerYear = 252) {
+  if (returns.length === 0) {
+    return 0;
+  }
+  const avgReturn = returns.reduce((a, b) => a + b, 0) / returns.length;
+  const stdDev2 = Math.sqrt(returns.reduce((sum, r) => sum + Math.pow(r - avgReturn, 2), 0) / returns.length);
+  if (stdDev2 === 0) {
+    return 0;
+  }
+  const excessReturn = avgReturn - riskFreeRate / periodsPerYear;
+  const sharpeRatio = excessReturn / stdDev2;
+  const annualizedSharpe = sharpeRatio * Math.sqrt(periodsPerYear);
+  return annualizedSharpe;
+}
+function calculateSharpeRatioFull(returns, riskFreeRate = 0.04, periodsPerYear = 252) {
+  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 stdDev2 = Math.sqrt(returns.reduce((sum, r) => sum + Math.pow(r - avgReturn, 2), 0) / returns.length);
+  if (stdDev2 === 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 / stdDev2;
+  const annualizedSharpe = sharpeRatio * Math.sqrt(periodsPerYear);
+  return {
+    sharpe_ratio: sharpeRatio,
+    annualized_sharpe: annualizedSharpe,
+    risk_free_rate: riskFreeRate,
+    avg_return: avgReturn,
+    std_dev: stdDev2
+  };
+}
+var calculate_var = calculateVar;
+var calculate_drawdown = calculateDrawdown;
+var calculate_sharpe_ratio = calculateSharpeRatio;
+var sharpeRatio = calculateSharpeRatio;
+function calculateSortinoRatio(returns, riskFreeRate = 0.04, periodsPerYear = 252) {
+  if (returns.length === 0)
+    return 0;
+  const avgReturn = returns.reduce((a, b) => a + b, 0) / returns.length;
+  const target = riskFreeRate / periodsPerYear;
+  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);
+}
+function calculateBetaAlpha(assetReturns, benchmarkReturns) {
+  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;
+  const cov = assetReturns.reduce((sum, a, i) => sum + (a - avgAsset) * (benchmarkReturns[i] - avgBench), 0) / n;
+  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 };
+}
+var calculate_sortino_ratio = calculateSortinoRatio;
+var calculate_beta_alpha = calculateBetaAlpha;
+var src_default = {
+  getVersion,
+  clearError,
+  getLibraryPath,
+  createOHLCV,
+  createAMM,
+  ammCalculateCost,
+  ammCalculateCostFull,
+  ammPriceImpact,
+  amm_buy_cost,
+  amm_calculate_cost,
+  amm_price_impact,
+  lmsrPrice,
+  lmsrCost,
+  lmsrCalculate,
+  kellyCriterion,
+  kelly_criterion,
+  detectArbitrage,
+  detect_arbitrage,
+  convertOdds,
+  convert_odds,
+  mean,
+  stdDev,
+  std_dev,
+  variance,
+  correlation,
+  sma,
+  ema,
+  rsi,
+  macd,
+  calculateVar,
+  calculate_var,
+  calculateDrawdown,
+  calculate_drawdown,
+  calculateSharpeRatio,
+  calculateSharpeRatioFull,
+  calculate_sharpe_ratio,
+  sharpeRatio,
+  calculateSortinoRatio,
+  calculate_sortino_ratio,
+  calculateBetaAlpha,
+  calculate_beta_alpha
+};
+export {
+  variance,
+  std_dev,
+  stdDev,
+  sma,
+  sharpeRatio,
+  rsi,
+  positionSizeFixedFractional,
+  mean,
+  macd,
+  lmsrPrice,
+  lmsrCost,
+  lmsrCalculate,
+  kelly_criterion,
+  kellyCriterion,
+  getVersion,
+  getLibraryPath,
+  ema,
+  detect_arbitrage,
+  detectArbitrage,
+  src_default as default,
+  createOHLCV,
+  createAMM,
+  correlation,
+  convert_odds,
+  convertOdds,
+  clearError,
+  calculate_var,
+  calculate_sortino_ratio,
+  calculate_sharpe_ratio,
+  calculate_drawdown,
+  calculate_beta_alpha,
+  calculateVar,
+  calculateSortinoRatio,
+  calculateSharpeRatioFull,
+  calculateSharpeRatio,
+  calculateEdge,
+  calculateDrawdown,
+  calculateBetaAlpha,
+  amm_price_impact,
+  amm_calculate_cost,
+  amm_buy_cost,
+  ammPriceImpact,
+  ammCalculateCostFull,
+  ammCalculateCost,
+  Signal,
+  CandlePattern
+};