website: redesign part 11

2026-07-10 10:38:14 -07:00 · 2026-06-06 22:29:33 +02:00
parent 66dc7cd8f5
commit 041c542046
49 changed files with 17275 additions and 193 deletions
@@ -0,0 +1,402 @@
+#!/usr/bin/env node
+
+const PCTS = [100, 95, 90, 85, 80, 75, 70, 65, 60, 55, 50, 45, 40];
+const DAYS_PER_MONTH = 365.2425 / 12;
+
+function parseArgs(argv) {
+  const opts = {
+    baseUrl: "https://bitview.space",
+    dataStart: "2014-01-01",
+    end: "2026-06-06",
+    startFrom: "2017-12-01",
+    startTo: "2025-08-01",
+    starts: null,
+    initialCash: 10_000,
+    monthlyTopup: 1_000,
+    initialDeployDays: 365,
+    topMin: 0.25,
+    topMax: 8,
+    bottomMin: 0.25,
+    bottomMax: 16,
+    step: 0.25,
+    sellMin: 0,
+    sellMax: 10,
+    sellStep: 1,
+    topN: 12,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    const next = () => {
+      i += 1;
+      if (i >= argv.length) throw new Error(`Missing value for ${arg}`);
+      return argv[i];
+    };
+
+    if (arg === "--base-url") opts.baseUrl = next();
+    else if (arg === "--data-start") opts.dataStart = next();
+    else if (arg === "--end") opts.end = next();
+    else if (arg === "--start-from") opts.startFrom = next();
+    else if (arg === "--start-to") opts.startTo = next();
+    else if (arg === "--starts") opts.starts = next().split(",").filter(Boolean);
+    else if (arg === "--top-min") opts.topMin = Number(next());
+    else if (arg === "--top-max") opts.topMax = Number(next());
+    else if (arg === "--bottom-min") opts.bottomMin = Number(next());
+    else if (arg === "--bottom-max") opts.bottomMax = Number(next());
+    else if (arg === "--step") opts.step = Number(next());
+    else if (arg === "--sell-min") opts.sellMin = Number(next());
+    else if (arg === "--sell-max") opts.sellMax = Number(next());
+    else if (arg === "--sell-step") opts.sellStep = Number(next());
+    else if (arg === "--top-n") opts.topN = Number(next());
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return opts;
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const rows = await loadRows(opts);
+  const starts = resolveStarts(rows, opts);
+  const startStates = starts.map((start) => ({
+    ...start,
+    phase: inferPhase(rows, start.index),
+    dca: simulateSimpleDailyDca(rows, start.index, opts),
+    lump: simulateLumpAndTopup(rows, start.index, opts),
+  }));
+  const baselineWeights = linearWeights(1, 7);
+  const baseline = scoreVariant(rows, startStates, baselineWeights, 1, opts);
+
+  const candidates = [];
+  for (const top of range(opts.topMin, opts.topMax, opts.step)) {
+    const bottomStart = Math.max(opts.bottomMin, top);
+    for (const bottom of range(bottomStart, opts.bottomMax, opts.step)) {
+      const weights = linearWeights(top, bottom);
+      for (const sellMultiple of range(opts.sellMin, opts.sellMax, opts.sellStep)) {
+        const score = scoreVariant(rows, startStates, weights, sellMultiple, opts);
+        candidates.push({
+          top,
+          bottom,
+          sellMultiple,
+          ...score,
+        });
+      }
+    }
+  }
+
+  candidates.sort((a, b) => b.avgVsDca - a.avgVsDca);
+
+  console.log(
+    [
+      `Starts: ${starts[0].date} to ${starts.at(-1).date} (${starts.length})`,
+      `Data end: ${rows.at(-1).date}`,
+      `Baseline p100=1 -> p40=7, sell x1: avg vs DCA ${fmtPct(baseline.avgVsDca)}, median vs DCA ${fmtPct(baseline.medianVsDca)}, worst vs DCA ${fmtPct(baseline.worstVsDca)}, avg final ${usd(baseline.avgFinal)}`,
+      "",
+      "rank,p100,p40,sell_x,avg_vs_dca,median_vs_dca,worst_vs_dca,avg_vs_lump,avg_final,wins_vs_baseline",
+    ].join("\n"),
+  );
+
+  for (const [index, candidate] of candidates.slice(0, opts.topN).entries()) {
+    console.log(
+      [
+        index + 1,
+        fmt(candidate.top),
+        fmt(candidate.bottom),
+        fmt(candidate.sellMultiple),
+        fmtPct(candidate.avgVsDca),
+        fmtPct(candidate.medianVsDca),
+        fmtPct(candidate.worstVsDca),
+        fmtPct(candidate.avgVsLump),
+        usd(candidate.avgFinal),
+        candidate.finals.filter((value, i) => value > baseline.finals[i]).length,
+      ].join(","),
+    );
+  }
+}
+
+async function loadRows(opts) {
+  const names = [
+    "date",
+    "price",
+    "price_ath",
+    ...PCTS.map(costBasisSeriesName),
+  ];
+  const loaded = new Map(
+    await Promise.all(names.map(async (name) => [name, await fetchSeries(opts, name)])),
+  );
+  const len = Math.min(...names.map((name) => loaded.get(name).data.length));
+  const rows = [];
+
+  for (let i = 0; i < len; i += 1) {
+    const row = {
+      date: loaded.get("date").data[i],
+      price: loaded.get("price").data[i],
+      ath: loaded.get("price_ath").data[i],
+      previousAth: i > 0 ? loaded.get("price_ath").data[i - 1] : loaded.get("price_ath").data[i],
+      levels: {},
+    };
+    for (const pct of PCTS) {
+      row.levels[pct] = loaded.get(costBasisSeriesName(pct)).data[i];
+    }
+    rows.push(row);
+  }
+
+  return rows;
+}
+
+async function fetchSeries(opts, series) {
+  const url = new URL(`/api/series/${series}/day1`, normalizeBaseUrl(opts.baseUrl));
+  url.searchParams.set("start", opts.dataStart);
+  if (opts.end) url.searchParams.set("end", opts.end);
+
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`Failed to fetch ${series}: ${response.status}`);
+  const json = await response.json();
+  if (!Array.isArray(json.data)) throw new Error(`${series} returned no data array`);
+  return json;
+}
+
+function resolveStarts(rows, opts) {
+  const dates = opts.starts ?? monthStarts(opts.startFrom, opts.startTo);
+  return dates.map((date) => ({
+    date,
+    index: findDateIndex(rows, date),
+  }));
+}
+
+function monthStarts(from, to) {
+  const dates = [];
+  for (
+    const cursor = new Date(`${from}T00:00:00Z`), end = new Date(`${to}T00:00:00Z`);
+    cursor <= end;
+    cursor.setUTCMonth(cursor.getUTCMonth() + 1)
+  ) {
+    dates.push(cursor.toISOString().slice(0, 10));
+  }
+  return dates;
+}
+
+function findDateIndex(rows, date) {
+  const index = rows.findIndex((row) => row.date >= date);
+  if (index === -1) throw new Error(`Date ${date} is outside loaded data`);
+  return index;
+}
+
+function inferPhase(rows, startIndex) {
+  let buyActive = false;
+  let sellArmed = false;
+
+  for (let i = 0; i < startIndex; i += 1) {
+    const row = rows[i];
+    const p50 = row.levels[50];
+
+    if (Number.isFinite(p50) && p50 > 0 && row.price <= p50) {
+      buyActive = true;
+      sellArmed = false;
+    }
+
+    if (buyActive && isP100Increase(row, rows[i - 1])) {
+      buyActive = false;
+      sellArmed = true;
+    }
+  }
+
+  return { buyActive, sellArmed };
+}
+
+function scoreVariant(rows, starts, weights, sellMultiple, opts) {
+  const finals = [];
+  const vsDca = [];
+  const vsLump = [];
+  const drawdowns = [];
+
+  for (const start of starts) {
+    const result = simulateSignal(rows, start.index, start.phase, weights, sellMultiple, opts);
+    finals.push(result.finalValue);
+    vsDca.push(result.finalValue / start.dca.finalValue - 1);
+    vsLump.push(result.finalValue / start.lump.finalValue - 1);
+    drawdowns.push(result.maxDrawdown);
+  }
+
+  return {
+    finals,
+    avgFinal: avg(finals),
+    avgVsDca: avg(vsDca),
+    medianVsDca: median(vsDca),
+    worstVsDca: Math.min(...vsDca),
+    avgVsLump: avg(vsLump),
+    avgDrawdown: avg(drawdowns),
+  };
+}
+
+function simulateSignal(rows, startIndex, phase, weights, sellMultiple, opts) {
+  let cash = opts.initialCash;
+  let btc = 0;
+  let buyActive = phase.buyActive;
+  let sellArmed = phase.sellArmed;
+  let initialDeployActiveDays = 0;
+  let peakValue = cash;
+  let maxDrawdown = 0;
+  const baseDailyBuy = opts.monthlyTopup / DAYS_PER_MONTH;
+
+  for (let i = startIndex; i < rows.length; i += 1) {
+    const row = rows[i];
+    if (i > startIndex && isMonthStart(row.date)) cash += opts.monthlyTopup;
+
+    const p50 = row.levels[50];
+    if (Number.isFinite(p50) && p50 > 0 && row.price <= p50) {
+      buyActive = true;
+      sellArmed = false;
+    }
+
+    if (buyActive && isP100Increase(row, rows[i - 1])) {
+      buyActive = false;
+      sellArmed = true;
+    }
+
+    if (sellMultiple > 0 && sellArmed && isInsideSellBand(row) && btc > 0) {
+      const btcToSell = btc * Math.min(1, 0.005 * sellMultiple);
+      btc -= btcToSell;
+      cash += btcToSell * row.price;
+    }
+
+    if (buyActive && cash > 0) {
+      const initialBudget =
+        initialDeployActiveDays < opts.initialDeployDays
+          ? opts.initialCash / opts.initialDeployDays
+          : 0;
+      const usd = Math.min(
+        cash,
+        (baseDailyBuy + initialBudget) * buyWeight(row, weights),
+      );
+      if (usd > 0) {
+        btc += usd / row.price;
+        cash -= usd;
+        initialDeployActiveDays += 1;
+      }
+    }
+
+    const value = cash + btc * row.price;
+    peakValue = Math.max(peakValue, value);
+    maxDrawdown = Math.max(maxDrawdown, peakValue === 0 ? 0 : 1 - value / peakValue);
+  }
+
+  return {
+    finalValue: cash + btc * rows.at(-1).price,
+    maxDrawdown,
+  };
+}
+
+function simulateLumpAndTopup(rows, startIndex, opts) {
+  let btc = opts.initialCash / rows[startIndex].price;
+  for (let i = startIndex + 1; i < rows.length; i += 1) {
+    if (isMonthStart(rows[i].date)) btc += opts.monthlyTopup / rows[i].price;
+  }
+  return { finalValue: btc * rows.at(-1).price };
+}
+
+function simulateSimpleDailyDca(rows, startIndex, opts) {
+  let cash = opts.initialCash;
+  let btc = 0;
+  const baseDailyBuy = opts.monthlyTopup / DAYS_PER_MONTH;
+
+  for (let i = startIndex; i < rows.length; i += 1) {
+    const row = rows[i];
+    if (i > startIndex && isMonthStart(row.date)) cash += opts.monthlyTopup;
+
+    const elapsedDays = i - startIndex;
+    const initialBudget =
+      elapsedDays < opts.initialDeployDays ? opts.initialCash / opts.initialDeployDays : 0;
+    const usd = Math.min(cash, baseDailyBuy + initialBudget);
+    if (usd > 0) {
+      btc += usd / row.price;
+      cash -= usd;
+    }
+  }
+
+  return { finalValue: cash + btc * rows.at(-1).price };
+}
+
+function linearWeights(top, bottom) {
+  const weights = {};
+  for (let i = 0; i < PCTS.length; i += 1) {
+    weights[PCTS[i]] = top + ((bottom - top) * i) / (PCTS.length - 1);
+  }
+  return weights;
+}
+
+function buyWeight(row, weights) {
+  let weight = 0;
+  for (const pct of PCTS) {
+    const level = row.levels[pct];
+    if (Number.isFinite(level) && level > 0 && row.price <= level) {
+      weight = Math.max(weight, weights[pct]);
+    }
+  }
+  return weight;
+}
+
+function isP100Increase(row, previousRow) {
+  const level = row.levels[100];
+  const previousLevel = previousRow?.levels[100];
+  return Number.isFinite(level) && Number.isFinite(previousLevel) && level > previousLevel;
+}
+
+function isInsideSellBand(row) {
+  const p95 = row.levels[95];
+  const p100 = row.levels[100];
+  if (!Number.isFinite(p95) || !Number.isFinite(p100) || p95 <= 0 || p100 <= 0) {
+    return false;
+  }
+  const lower = Math.min(p95, p100);
+  const upper = Math.max(p95, p100);
+  return row.price >= lower && row.price <= upper;
+}
+
+function costBasisSeriesName(pct) {
+  if (pct === 100) return "cost_basis_max";
+  return `cost_basis_per_coin_pct${String(pct).padStart(2, "0")}`;
+}
+
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+}
+
+function isMonthStart(date) {
+  return date.endsWith("-01");
+}
+
+function range(min, max, step) {
+  const values = [];
+  const scale = 1 / step;
+  for (let value = min; value <= max + step / 10; value += step) {
+    values.push(Math.round(value * scale) / scale);
+  }
+  return values;
+}
+
+function avg(values) {
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+
+function median(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  return sorted[Math.floor(sorted.length / 2)];
+}
+
+function fmt(value) {
+  return String(Number(value.toFixed(2)));
+}
+
+function fmtPct(value) {
+  return `${(value * 100).toFixed(2)}%`;
+}
+
+function usd(value) {
+  return `$${(value / 1000).toFixed(1)}k`;
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exitCode = 1;
+});