tradeblocks-mcp 3.0.0 → 3.0.2

package/dist/iv-solver-worker.js

@@ -0,0 +1,295 @@
+// src/utils/iv-solver-worker.ts
+import { parentPort } from "node:worker_threads";
+
+// src/utils/black-scholes.ts
+var BACHELIER_DTE_THRESHOLD = 0.1;
+function pdf(x) {
+  return Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI);
+}
+function cdf(x) {
+  if (x < -10) return 0;
+  if (x > 10) return 1;
+  const sign = x < 0 ? -1 : 1;
+  const absX = Math.abs(x);
+  const p = 0.2316419;
+  const b1 = 0.31938153;
+  const b2 = -0.356563782;
+  const b3 = 1.781477937;
+  const b4 = -1.821255978;
+  const b5 = 1.330274429;
+  const t = 1 / (1 + p * absX);
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const t4 = t3 * t;
+  const t5 = t4 * t;
+  const poly = b1 * t + b2 * t2 + b3 * t3 + b4 * t4 + b5 * t5;
+  const result = 1 - pdf(absX) * poly;
+  return sign === 1 ? result : 1 - result;
+}
+function d1d2(S, K, T, r, q, sigma) {
+  const sqrtT = Math.sqrt(T);
+  const d1 = (Math.log(S / K) + (r - q + 0.5 * sigma * sigma) * T) / (sigma * sqrtT);
+  const d2 = d1 - sigma * sqrtT;
+  return { d1, d2 };
+}
+function bsPrice(type, S, K, T, r, q, sigma) {
+  if (T <= 0) {
+    return type === "call" ? Math.max(S - K, 0) : Math.max(K - S, 0);
+  }
+  if (sigma <= 0) {
+    const forward = S * Math.exp((r - q) * T);
+    if (type === "call") {
+      return Math.max(forward - K, 0) * Math.exp(-r * T);
+    } else {
+      return Math.max(K - forward, 0) * Math.exp(-r * T);
+    }
+  }
+  const { d1, d2 } = d1d2(S, K, T, r, q, sigma);
+  if (type === "call") {
+    return S * Math.exp(-q * T) * cdf(d1) - K * Math.exp(-r * T) * cdf(d2);
+  } else {
+    return K * Math.exp(-r * T) * cdf(-d2) - S * Math.exp(-q * T) * cdf(-d1);
+  }
+}
+function bsDelta(type, S, K, T, r, q, sigma) {
+  if (T <= 0 || sigma <= 0) {
+    if (type === "call") return S > K ? 1 : 0;
+    return S < K ? -1 : 0;
+  }
+  const { d1 } = d1d2(S, K, T, r, q, sigma);
+  const eqT = Math.exp(-q * T);
+  if (type === "call") {
+    return cdf(d1) * eqT;
+  } else {
+    return (cdf(d1) - 1) * eqT;
+  }
+}
+function bsGamma(S, K, T, r, q, sigma) {
+  if (T <= 0 || sigma <= 0) return 0;
+  const { d1 } = d1d2(S, K, T, r, q, sigma);
+  return pdf(d1) * Math.exp(-q * T) / (S * sigma * Math.sqrt(T));
+}
+function bsTheta(type, S, K, T, r, q, sigma) {
+  if (T <= 0 || sigma <= 0) return 0;
+  const { d1, d2 } = d1d2(S, K, T, r, q, sigma);
+  const sqrtT = Math.sqrt(T);
+  const eqT = Math.exp(-q * T);
+  const erT = Math.exp(-r * T);
+  const term1 = -(S * eqT * pdf(d1) * sigma) / (2 * sqrtT);
+  if (type === "call") {
+    const term2 = q * S * eqT * cdf(d1);
+    const term3 = -r * K * erT * cdf(d2);
+    return (term1 - term2 - term3) / 365;
+  } else {
+    const term2 = q * S * eqT * cdf(-d1);
+    const term3 = -r * K * erT * cdf(-d2);
+    return (term1 + term2 + term3) / 365;
+  }
+}
+function bsVega(S, K, T, r, q, sigma) {
+  if (T <= 0 || sigma <= 0) return 0;
+  const { d1 } = d1d2(S, K, T, r, q, sigma);
+  return S * Math.exp(-q * T) * pdf(d1) * Math.sqrt(T) / 100;
+}
+function solveIV(type, marketPrice, S, K, T, r, q, maxIter = 100, tolerance = 1e-6) {
+  if (marketPrice <= 0 || T <= 0) return null;
+  let sigma = 0.3;
+  let lo = 1e-3;
+  let hi = 5;
+  for (let i = 0; i < maxIter; i++) {
+    const price = bsPrice(type, S, K, T, r, q, sigma);
+    const diff = price - marketPrice;
+    if (Math.abs(diff) < tolerance) {
+      return sigma;
+    }
+    const { d1 } = d1d2(S, K, T, r, q, sigma);
+    const rawVega = S * Math.exp(-q * T) * pdf(d1) * Math.sqrt(T);
+    if (rawVega < 1e-10) {
+      const mid = (lo + hi) / 2;
+      if (diff > 0) {
+        hi = sigma;
+      } else {
+        lo = sigma;
+      }
+      sigma = mid;
+    } else {
+      const newSigma = sigma - diff / rawVega;
+      if (newSigma <= 0 || newSigma > 10) {
+        if (diff > 0) {
+          hi = sigma;
+        } else {
+          lo = sigma;
+        }
+        sigma = (lo + hi) / 2;
+      } else {
+        sigma = newSigma;
+      }
+    }
+  }
+  return null;
+}
+function bachelierPrice(type, S, K, T, r, q, sigma_n) {
+  if (T <= 0) return type === "call" ? Math.max(S - K, 0) : Math.max(K - S, 0);
+  if (sigma_n <= 0) {
+    const forward2 = S * Math.exp((r - q) * T);
+    return Math.exp(-r * T) * (type === "call" ? Math.max(forward2 - K, 0) : Math.max(K - forward2, 0));
+  }
+  const forward = S * Math.exp((r - q) * T);
+  const sqrtT = Math.sqrt(T);
+  const d = (forward - K) / (sigma_n * sqrtT);
+  const discount = Math.exp(-r * T);
+  if (type === "call") {
+    return discount * ((forward - K) * cdf(d) + sigma_n * sqrtT * pdf(d));
+  } else {
+    return discount * ((K - forward) * cdf(-d) + sigma_n * sqrtT * pdf(d));
+  }
+}
+function bachelierDelta(type, S, K, T, r, q, sigma_n) {
+  if (T <= 0 || sigma_n <= 0) {
+    if (type === "call") return S > K ? 1 : 0;
+    return S < K ? -1 : 0;
+  }
+  const forward = S * Math.exp((r - q) * T);
+  const d = (forward - K) / (sigma_n * Math.sqrt(T));
+  const discount = Math.exp(-r * T);
+  return type === "call" ? discount * cdf(d) : -discount * cdf(-d);
+}
+function bachelierGamma(S, K, T, r, q, sigma_n) {
+  if (T <= 0 || sigma_n <= 0) return 0;
+  const forward = S * Math.exp((r - q) * T);
+  const sqrtT = Math.sqrt(T);
+  const d = (forward - K) / (sigma_n * sqrtT);
+  return Math.exp(-r * T) * pdf(d) / (sigma_n * sqrtT);
+}
+function bachelierTheta(type, S, K, T, r, q, sigma_n) {
+  if (T <= 0 || sigma_n <= 0) return 0;
+  const forward = S * Math.exp((r - q) * T);
+  const sqrtT = Math.sqrt(T);
+  const d = (forward - K) / (sigma_n * sqrtT);
+  const discount = Math.exp(-r * T);
+  const price = bachelierPrice(type, S, K, T, r, q, sigma_n);
+  const annualTheta = -discount * sigma_n * pdf(d) / (2 * sqrtT) + r * price;
+  return annualTheta / 365;
+}
+function bachelierVega(S, K, T, r, q, sigma_n) {
+  if (T <= 0 || sigma_n <= 0) return 0;
+  const forward = S * Math.exp((r - q) * T);
+  const d = (forward - K) / (sigma_n * Math.sqrt(T));
+  return Math.exp(-r * T) * Math.sqrt(T) * pdf(d) / 100;
+}
+function solveNormalIV(type, marketPrice, S, K, T, r, q, maxIter = 100, tolerance = 1e-6) {
+  if (marketPrice <= 0 || T <= 0) return null;
+  let sigma_n = marketPrice / Math.sqrt(T / (2 * Math.PI));
+  sigma_n = Math.max(sigma_n, 1);
+  let lo = 0.01;
+  let hi = 5e4;
+  for (let i = 0; i < maxIter; i++) {
+    const price = bachelierPrice(type, S, K, T, r, q, sigma_n);
+    const diff = price - marketPrice;
+    if (Math.abs(diff) < tolerance) return sigma_n;
+    const forward = S * Math.exp((r - q) * T);
+    const d = (forward - K) / (sigma_n * Math.sqrt(T));
+    const rawVega = Math.exp(-r * T) * Math.sqrt(T) * pdf(d);
+    if (rawVega < 1e-10) {
+      if (diff > 0) {
+        hi = sigma_n;
+      } else {
+        lo = sigma_n;
+      }
+      sigma_n = (lo + hi) / 2;
+    } else {
+      const newSigma = sigma_n - diff / rawVega;
+      if (newSigma <= 0 || newSigma > 1e5) {
+        if (diff > 0) {
+          hi = sigma_n;
+        } else {
+          lo = sigma_n;
+        }
+        sigma_n = (lo + hi) / 2;
+      } else {
+        sigma_n = newSigma;
+      }
+    }
+  }
+  return null;
+}
+function computeLegGreeks(optionPrice, underlyingPrice, strike, dte, type, riskFreeRate, dividendYield) {
+  const T = dte / 365;
+  const bsType = type === "C" ? "call" : "put";
+  const nullResult = { delta: null, gamma: null, theta: null, vega: null, iv: null };
+  if (dte < BACHELIER_DTE_THRESHOLD) {
+    const iv2 = solveNormalIV(bsType, optionPrice, underlyingPrice, strike, T, riskFreeRate, dividendYield);
+    if (iv2 === null) return nullResult;
+    return {
+      delta: bachelierDelta(bsType, underlyingPrice, strike, T, riskFreeRate, dividendYield, iv2),
+      gamma: bachelierGamma(underlyingPrice, strike, T, riskFreeRate, dividendYield, iv2),
+      theta: bachelierTheta(bsType, underlyingPrice, strike, T, riskFreeRate, dividendYield, iv2),
+      vega: bachelierVega(underlyingPrice, strike, T, riskFreeRate, dividendYield, iv2),
+      iv: iv2,
+      model: "bachelier"
+    };
+  }
+  const iv = solveIV(bsType, optionPrice, underlyingPrice, strike, T, riskFreeRate, dividendYield);
+  if (iv === null) return nullResult;
+  return {
+    delta: bsDelta(bsType, underlyingPrice, strike, T, riskFreeRate, dividendYield, iv),
+    gamma: bsGamma(underlyingPrice, strike, T, riskFreeRate, dividendYield, iv),
+    theta: bsTheta(bsType, underlyingPrice, strike, T, riskFreeRate, dividendYield, iv),
+    vega: bsVega(underlyingPrice, strike, T, riskFreeRate, dividendYield, iv),
+    iv,
+    model: "bs"
+  };
+}
+
+// src/utils/iv-solver-worker.ts
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function solveIvBatch(req) {
+  const { id, count } = req;
+  const delta = new Float64Array(count);
+  const gamma = new Float64Array(count);
+  const theta = new Float64Array(count);
+  const vega = new Float64Array(count);
+  const iv = new Float64Array(count);
+  const ok = new Uint8Array(count);
+  for (let i = 0; i < count; i++) {
+    const result = computeLegGreeks(
+      req.optionPrice[i],
+      req.underlyingPrice[i],
+      req.strike[i],
+      req.dte[i],
+      req.type[i] === 0 ? "C" : "P",
+      req.riskFreeRate[i],
+      req.dividendYield[i]
+    );
+    if (isFiniteNumber(result.delta) && isFiniteNumber(result.gamma) && isFiniteNumber(result.theta) && isFiniteNumber(result.vega) && isFiniteNumber(result.iv)) {
+      delta[i] = result.delta;
+      gamma[i] = result.gamma;
+      theta[i] = result.theta;
+      vega[i] = result.vega;
+      iv[i] = result.iv;
+      ok[i] = 1;
+    } else {
+      ok[i] = 0;
+    }
+  }
+  return { id, count, delta, gamma, theta, vega, iv, ok };
+}
+if (parentPort) {
+  const port = parentPort;
+  port.on("message", (req) => {
+    const reply = solveIvBatch(req);
+    port.postMessage(reply, [
+      reply.delta.buffer,
+      reply.gamma.buffer,
+      reply.theta.buffer,
+      reply.vega.buffer,
+      reply.iv.buffer,
+      reply.ok.buffer
+    ]);
+  });
+}
+export {
+  solveIvBatch
+};

package/dist/{market-provider-GGLA7ACC.js → market-provider-VDRJUEF2.js}

@@ -1,7 +1,7 @@
 import {
   _resetProvider,
   getProvider
-} from "./chunk-CCITWAAI.js";
+} from "./chunk-XXYOUIZY.js";
 import "./chunk-QTTR7AAW.js";
 import "./chunk-PRAYH3RT.js";
 import "./chunk-W2PP3LEH.js";
@@ -13,4 +13,4 @@ export {
   _resetProvider,
   getProvider
 };
-//# sourceMappingURL=market-provider-GGLA7ACC.js.map
+//# sourceMappingURL=market-provider-VDRJUEF2.js.map

package/dist/test-exports.js

@@ -83,6 +83,7 @@ import {
 } from "./chunk-4BLCXNQ6.js";
 import {
   BACHELIER_DTE_THRESHOLD,
+  IvSolverPool,
   MASSIVE_BASE_URL,
   MASSIVE_MAX_LIMIT,
   MASSIVE_MAX_PAGES,
@@ -100,6 +101,7 @@ import {
   ThetaMddsClient,
   _resetProvider,
   applyQuoteGreeks,
+  applyQuoteGreeksParallel,
   bachelierDelta,
   bachelierGamma,
   bachelierPrice,
@@ -118,9 +120,11 @@ import {
   computeStrategyPnlPath,
   computeThetaQuoteMidGreekRow,
   decodeThetaResponseData,
+  destroySharedIvSolverPool,
   findNearestTimestamp,
   fromMassiveTicker,
   getProvider,
+  getSharedIvSolverPool,
   hasQuoteGreeks,
   indexHistoryEod,
   indexHistoryOhlc,
@@ -152,7 +156,7 @@ import {
   stockHistoryOhlc,
   thetaTimestampToEtMinute,
   toMassiveTicker
-} from "./chunk-CCITWAAI.js";
+} from "./chunk-XXYOUIZY.js";
 import {
   PortfolioStatsCalculator,
   calculateCorrelationMatrix,
@@ -8663,7 +8667,7 @@ var MarketIngestor = class {
         underlyingPriceByTime.set(time, bar.open);
       }
     }
-    const stats = applyQuoteGreeks({
+    const stats = await applyQuoteGreeksParallel({
       rows,
       getDate: (row) => row.timestamp.slice(0, 10),
       getTime: (row) => row.timestamp.slice(11, 16),
@@ -9654,6 +9658,7 @@ export {
   ENRICHED_FIELD_TYPES,
   EnrichedStore,
   EnrichmentWatermarksSchema,
+  IvSolverPool,
   LEVERAGED_ETFS,
   MASSIVE_BASE_URL,
   MASSIVE_MAX_LIMIT,
@@ -9695,6 +9700,7 @@ export {
   analyzeStructureFitSchema,
   appendBackfillManifestLineDurable,
   applyQuoteGreeks,
+  applyQuoteGreeksParallel,
   assessPrecision,
   bachelierDelta,
   bachelierGamma,
@@ -9770,6 +9776,7 @@ export {
   deleteProfileSchema,
   deleteSyncMetadataJson,
   describeReadParquetColumns,
+  destroySharedIvSolverPool,
   detectCsvType,
   discoverCsvFiles,
   downgradeToReadOnly,
@@ -9806,6 +9813,7 @@ export {
   getProvider,
   getReadOnlyConnection,
   getResolvedProviderCapabilities,
+  getSharedIvSolverPool,
   getStrategyProfileSchema,
   getSyncMetadataJson,
   groupBackfillTickersByGreekBand,