dexbot 1.4.16 → 1.4.17

package/analysis/ama_fitting/fetch_lp_candles.ts

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { normalizePoolId } from '../../market_adapter/utils/chain.js';
+import { toIntervalLabel } from '../../market_adapter/interval_utils.js';
+import { MARKET_ADAPTER } from '../../modules/constants.js';
+import * as kibanaSource from '../../market_adapter/inputs/kibana_source.js';
+import { PATHS } from '../../modules/paths.js';
+import { getStorage } from '../../modules/storage/index.js';
+const { ensureDir, writeJSON } = getStorage();
+import { getErrorMessage } from '../../modules/utils/errors.js';
+
+'use strict';
+/**
+ * Fetch LP pool candles from Kibana for AMA optimizer input.
+ *
+ * Uses the same kibana_source as the market_adapter bootstrap, but saves
+ * the full uncut dataset (no pruning) for optimizer use.
+ *
+ * Usage:
+ *   tsx analysis/ama_fitting/fetch_lp_candles.ts \
+ *     --pool 1.19.133 \
+ *     --assetA IOB.XRP --assetAId 1.3.3926 --assetAPrecision 4 \
+ *     --assetB BTS     --assetBId 1.3.0    --assetBPrecision 5 \
+ *     [--interval 1h] [--hours 26280] [--out my_file.json]
+ *
+ * Defaults: --interval 1h  --hours 26280 (3 years)
+ * Output: market_adapter/data/lp/<assetA>_<assetB>/lp_pool_<poolShort>_<interval>.json
+ */
+const DATA_DIR = PATHS.MARKET_ADAPTER.LP_DATA_DIR;
+const HOURS_3Y  = 3 * 365 * 24; // 26280
+function slugPart(value: string | null | undefined): string {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '') || 'unknown';
+}
+function slugPairFolder(symbolA: string, symbolB: string): string {
+    return `${slugPart(symbolA)}_${slugPart(symbolB)}`;
+}
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const out: {
+        pool: string | null;
+        assetASymbol: string | null;
+        assetAId: string | null;
+        assetAPrecision: number | null;
+        assetBSymbol: string | null;
+        assetBId: string | null;
+        assetBPrecision: number | null;
+        intervalSeconds: number;
+        hours: number;
+        outFile: string | null;
+    } = {
+        pool:             null,
+        assetASymbol:     null,
+        assetAId:         null,
+        assetAPrecision:  null,
+        assetBSymbol:     null,
+        assetBId:         null,
+        assetBPrecision:  null,
+        intervalSeconds:  MARKET_ADAPTER.RUNTIME_DEFAULTS.intervalSeconds,
+        hours:            HOURS_3Y,
+        outFile:          null,
+    };
+    const intervalMap: Record<string, number> = { '1m': 60, '5m': 300, '15m': 900, '1h': 3600, '4h': 14400, '1d': 86400 };
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        const v = args[i + 1];
+        switch (a) {
+            case '--pool':             out.pool             = v;         i++; break;
+            case '--assetA':           out.assetASymbol     = v;         i++; break;
+            case '--assetAId':         out.assetAId         = v;         i++; break;
+            case '--assetAPrecision':  out.assetAPrecision  = Number(v); i++; break;
+            case '--assetB':           out.assetBSymbol     = v;         i++; break;
+            case '--assetBId':         out.assetBId         = v;         i++; break;
+            case '--assetBPrecision':  out.assetBPrecision  = Number(v); i++; break;
+            case '--interval':         out.intervalSeconds  = intervalMap[v] ?? parseInt(v, 10); i++; break;
+            case '--hours':            out.hours            = Number(v); i++; break;
+            case '--out':              out.outFile          = v;         i++; break;
+            case '--help':
+            case '-h':
+                printHelp();
+                process.exit(0);
+        }
+    }
+    return out;
+}
+function printHelp() {
+    console.log('fetch_lp_candles.ts — fetch LP pool candles from Kibana for AMA optimizer');
+    console.log('');
+    console.log('Usage:');
+    console.log('  tsx fetch_lp_candles.ts --pool 1.19.133 \\');
+    console.log('    --assetA IOB.XRP --assetAId 1.3.3926 --assetAPrecision 4 \\');
+    console.log('    --assetB BTS     --assetBId 1.3.0    --assetBPrecision 5');
+    console.log('');
+    console.log('Options:');
+    console.log('  --pool <id>              Pool ID (e.g. 1.19.133)');
+    console.log('  --assetA <symbol>        Asset A symbol (e.g. IOB.XRP)');
+    console.log('  --assetAId <id>          Asset A object ID (e.g. 1.3.3926)');
+    console.log('  --assetAPrecision <n>    Asset A precision (e.g. 8)');
+    console.log('  --assetB <symbol>        Asset B symbol (e.g. BTS)');
+    console.log('  --assetBId <id>          Asset B object ID (e.g. 1.3.0)');
+    console.log('  --assetBPrecision <n>    Asset B precision (e.g. 5)');
+    console.log('  --interval <label>       Candle interval (1m, 5m, 15m, 1h, 4h, 1d; default: 1h)');
+    console.log('  --hours <n>              Lookback hours (default: 26280 = 3 years)');
+    console.log('  --out <filename>         Output filename (default: auto-generated in market_adapter/data/lp/)');
+}
+function validateArgs(args: Record<string, any>) {
+    if (!args.pool)            throw new Error('--pool is required');
+    if (!args.assetAId)        throw new Error('--assetAId is required');
+    if (!Number.isFinite(args.assetAPrecision)) throw new Error('--assetAPrecision is required');
+    if (!args.assetBId)        throw new Error('--assetBId is required');
+    if (!Number.isFinite(args.assetBPrecision)) throw new Error('--assetBPrecision is required');
+    if (!Number.isFinite(args.hours) || args.hours <= 0) throw new Error('--hours must be > 0');
+}
+async function main() {
+    const args = parseArgs();
+    validateArgs(args);
+    const assetA = {
+        id:        args.assetAId,
+        precision: args.assetAPrecision,
+        symbol:    args.assetASymbol || args.assetAId || '',
+    };
+    const assetB = {
+        id:        args.assetBId,
+        precision: args.assetBPrecision,
+        symbol:    args.assetBSymbol || args.assetBId || '',
+    };
+    const { intervalSeconds } = args;
+    const intervalLabel    = toIntervalLabel(intervalSeconds);
+    const poolId           = normalizePoolId(args.pool);
+    const lookback         = Math.round(args.hours);
+    const yearsApprox      = (lookback / (365 * 24)).toFixed(1);
+    console.log(`Fetching LP candles from Kibana`);
+    console.log(`  Pool:     ${poolId}`);
+    console.log(`  Pair:     ${assetA.symbol} / ${assetB.symbol}`);
+    console.log(`  Interval: ${intervalLabel}`);
+    console.log(`  Lookback: ${lookback}h (~${yearsApprox} years)`);
+    console.log('');
+    const candles = await kibanaSource.getLpCandlesForPool(poolId, assetA, assetB, {
+        intervalSeconds,
+        lookbackHours:         lookback,
+        consolidateByTimestamp: true,
+        apiKey:                null,
+        timeout:               60000,
+    });
+    if (!Array.isArray(candles) || candles.length === 0) {
+        throw new Error('Kibana returned no candles — check pool ID, asset IDs, and Kibana connectivity');
+    }
+    const firstTs = new Date(candles[0][0]).toISOString();
+    const lastTs  = new Date(candles[candles.length - 1][0]).toISOString();
+    console.log(`  Received: ${candles.length} candles  (${firstTs} → ${lastTs})`);
+    const payload = {
+        meta: {
+            fetchedAt:       new Date().toISOString(),
+            source:          'kibana',
+            pool:            poolId,
+            assetA,
+            assetB,
+            intervalSeconds,
+            lookbackHours:   lookback,
+            candleCount:     candles.length,
+            format:          '[timestamp_ms, open, high, low, close, volume_A]',
+        },
+        candles,
+    };
+    const poolShort = (poolId || '').replace('1.19.', '');
+    const pairFolder = slugPairFolder(assetA.symbol, assetB.symbol);
+    const defaultName = `lp_pool_${poolShort}_${intervalLabel}.json`;
+    const outName = args.outFile || defaultName;
+    const outPath = args.outFile && path.isAbsolute(args.outFile)
+        ? args.outFile
+        : path.join(DATA_DIR, pairFolder, outName);
+    const outDir = path.dirname(outPath);
+    if (!fs.existsSync(outDir)) ensureDir(outDir);
+    writeJSON(outPath, payload);
+    console.log(`  Saved:    ${path.relative(process.cwd(), outPath)}`);
+    console.log('');
+    console.log('Run optimizer:');
+    console.log(`  npm run build && node dist/analysis/ama_fitting/optimizer_high_resolution.js --data ${path.relative(process.cwd(), outPath)}`);
+}
+main().catch((err: any) => {
+    console.error('Error:', getErrorMessage(err));
+    process.exit(1);
+});

package/analysis/ama_fitting/generate_unified_comparison_chart.ts

@@ -0,0 +1,269 @@
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { calculateAMA } from '../../market_adapter/core/strategies/ama.js';
+import { generateHTML } from '../../market_adapter/lp_chart_core.js';
+import { toIntervalLabel } from '../../market_adapter/interval_utils.js';
+import { loadCandleFile } from '../math_utils.js';
+import { MARKET_ADAPTER } from '../../modules/constants.js';
+import { getStorage } from '../../modules/storage/index.js';
+const { ensureDir } = getStorage();
+import { PATHS } from '../../modules/paths.js';
+'use strict';
+
+/**
+ * UNIFIED COMPARISON CHART GENERATOR — Self-contained analysis chart
+ *
+ * Reads a local LP candle JSON file (any format: flat array, {candles: [...]},
+ * or {data: [...]}), computes AMA series, and writes an interactive HTML chart
+ * via the shared lp_chart_core renderer.
+ *
+ * No Kibana fetch, no market_adapter runtime deps beyond the core renderer.
+ *
+ * Usage:
+ *   tsx analysis/ama_fitting/generate_unified_comparison_chart.ts --data <file.json>
+ *   tsx analysis/ama_fitting/generate_unified_comparison_chart.ts  (auto-discovers newest lp_pool_*.json)
+ */
+
+
+
+// ── Config ─────────────────────────────────────────────────────────────────────
+
+const LP_DATA_DIR = PATHS.MARKET_ADAPTER.LP_DATA_DIR;
+const CHARTS_DIR = PATHS.ANALYSIS.CHARTS_DIR;
+
+const DEFAULT_COLORS = ['#26a69a', '#fb8c00', '#5c9ee6', '#ef5350'];
+const DEFAULT_DASHES = ['dot', 'solid', 'dash', 'dashdot'];
+
+function buildDefaultStrategies() {
+    const presets = MARKET_ADAPTER.AMAS as Record<string, typeof MARKET_ADAPTER.AMAS.AMA1>;
+    return Object.keys(presets).map((key, i) => ({
+        name: presets[key].name || key,
+        erPeriod: presets[key].erPeriod,
+        fastPeriod: presets[key].fastPeriod,
+        slowPeriod: presets[key].slowPeriod,
+        color: DEFAULT_COLORS[i % DEFAULT_COLORS.length],
+        dash: DEFAULT_DASHES[i % DEFAULT_DASHES.length],
+    }));
+}
+
+const DEFAULT_STRATEGIES = buildDefaultStrategies();
+
+// ── Data loading (self-contained, no lp_chart_runner dep) ──────────────────────
+
+function findLatestLpDataFile() {
+    if (!fs.existsSync(LP_DATA_DIR)) return null;
+    const stack = [LP_DATA_DIR];
+    const matches: { path: string; mtime: number }[] = [];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        if (!dir) continue;
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) { stack.push(full); continue; }
+            if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
+            if (!entry.name.startsWith('lp_pool_')) continue;
+            matches.push({ path: full, mtime: fs.statSync(full).mtimeMs });
+        }
+    }
+    matches.sort((a, b) => b.mtime - a.mtime);
+    return matches.length > 0 ? matches[0].path : null;
+}
+
+function normalizeCandle(c: any, index: any) {
+    if (Array.isArray(c)) {
+        if (c.length < 5) throw new Error(`Invalid candle at index ${index}: need at least 5 entries`);
+        return { timestamp: c[0], open: c[1], high: c[2], low: c[3], close: c[4], volume: c[5] ?? 0 };
+    }
+    if (c && typeof c === 'object') {
+        const { timestamp, open, high, low, close, volume = 0 } = c;
+        if ([timestamp, open, high, low, close].some(v => v == null)) {
+            throw new Error(`Invalid candle object at index ${index}`);
+        }
+        return { timestamp, open, high, low, close, volume };
+    }
+    throw new Error(`Unsupported candle format at index ${index}`);
+}
+
+function loadCandles(dataFile: any) {
+    const resolved = path.resolve(dataFile);
+    if (!fs.existsSync(resolved)) throw new Error(`File not found: ${resolved}`);
+
+    const { candles, meta } = loadCandleFile(resolved);
+
+    if (!Array.isArray(candles) || candles.length === 0) {
+        throw new Error('No candles found in file');
+    }
+
+    const candleObjects = candles.map((c, i) => normalizeCandle(c, i));
+    const candleArrays = candleObjects.map(c => [c.timestamp, c.open, c.high, c.low, c.close, c.volume]);
+
+    return { dataFile: resolved, meta, candleObjects, candleArrays };
+}
+
+// ── Metrics ────────────────────────────────────────────────────────────────────
+
+function calculateMetrics(amaValues: any, candles: any) {
+    let maxDriftUp = 0, maxDriftDown = 0, areaAbove = 0, areaBelow = 0;
+    const skip = Math.max(20, Math.floor(candles.length * 0.1));
+    for (let i = skip; i < candles.length; i++) {
+        const ama = amaValues[i];
+        const driftUp = (candles[i].high - ama) / ama;
+        const driftDown = (ama - candles[i].low) / ama;
+        if (driftUp > maxDriftUp) maxDriftUp = driftUp;
+        if (driftDown > maxDriftDown) maxDriftDown = driftDown;
+        if (candles[i].high > ama) areaAbove += driftUp;
+        if (candles[i].low < ama) areaBelow += driftDown;
+    }
+    return {
+        maxDriftUp, maxDriftDown, areaAbove, areaBelow,
+        totalArea: areaAbove + areaBelow,
+        maxDistance: Math.max(maxDriftUp, maxDriftDown),
+    };
+}
+
+// ── Output path ────────────────────────────────────────────────────────────────
+
+function defaultChartPath(meta: any) {
+    const intervalLabel = meta?.intervalSeconds
+        ? toIntervalLabel(meta.intervalSeconds)
+        : '1h';
+    const suffix = meta?.pool
+        ? `pool_${String(meta.pool).replace('1.19.', '')}`
+        : `${meta?.assetA?.symbol || 'unknown'}_${meta?.assetB?.symbol || 'pair'}`;
+    return path.join(CHARTS_DIR, `lp_chart_${suffix}_${intervalLabel}_UNIFIED_COMPARISON.html`);
+}
+
+// ── Help ───────────────────────────────────────────────────────────────────────
+
+function showHelp() {
+    console.log(`
+Unified Comparison Chart Generator
+
+Usage:
+  tsx generate_unified_comparison_chart.ts [options]
+
+Options:
+  --data FILE     LP candle export JSON file
+  --file FILE     Alias for --data
+  --output FILE   Output HTML file
+  --quiet         Suppress console output
+  --help          Show this help
+
+Notes:
+  - If --data is omitted, the newest lp_pool_*.json under market_adapter/data/lp is used.
+  - Accepts any candle JSON: flat [[ts,o,h,l,c,v],...], {candles: [...]}, or {data: [...]}.
+  - Separate from Kibana fetching — use fetch_lp_candles.ts to pull data first.
+`);
+}
+
+// ── Main ───────────────────────────────────────────────────────────────────────
+
+function parseArgs(argv: string[]) {
+    const cfg: { dataFile: string | null; outFile: string | null; quiet: boolean; help: boolean } = {
+        dataFile: null,
+        outFile: null,
+        quiet: false,
+        help: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if ((arg === '--data' || arg === '--file') && argv[i + 1]) {
+            cfg.dataFile = path.resolve(argv[++i]);
+        } else if ((arg === '--output' || arg === '--out') && argv[i + 1]) {
+            cfg.outFile = path.resolve(argv[++i]);
+        } else if (arg === '--quiet') {
+            cfg.quiet = true;
+        } else if (arg === '--help' || arg === '-h') {
+            cfg.help = true;
+        }
+    }
+    return cfg;
+}
+
+function generateChart(options = {} as Record<string, any>) {
+    const logger = options.logger ?? console;
+
+    const dataFile = options.dataFile
+        ? path.resolve(options.dataFile)
+        : findLatestLpDataFile();
+    if (!dataFile) {
+        throw new Error(`No LP data file found. Use --data <path> or run fetch_lp_candles.ts first.`);
+    }
+
+    const strategies = Array.isArray(options.strategies) && options.strategies.length
+        ? options.strategies
+        : [...DEFAULT_STRATEGIES];
+
+    const { meta, candleObjects, candleArrays } = loadCandles(dataFile);
+    const closes = candleObjects.map(c => c.close);
+
+    const enrichedMeta = {
+        ...(meta || {}),
+        assetA: meta?.assetA || { symbol: path.basename(dataFile, '.json') },
+        assetB: meta?.assetB || { symbol: '' },
+        intervalSeconds: meta?.intervalSeconds || 3600,
+        fetchedAt: meta?.fetchedAt || new Date().toISOString(),
+    };
+
+    logger.log(`Data:        ${path.relative(process.cwd(), dataFile)} (${candleObjects.length} candles)`);
+
+    const amaResults: any[] = [];
+    logger.log('');
+    for (const [index, strategy] of strategies.entries()) {
+        const values = calculateAMA(closes, strategy);
+        const metrics = calculateMetrics(values, candleObjects);
+        amaResults.push({ ...strategy, lineWidth: index === 0 ? 2 : 1.5, values });
+
+        logger.log(`${strategy.name}`);
+        logger.log(`   ├─ Total Area:     ${metrics.totalArea.toFixed(2)}%`);
+        logger.log(`   ├─ Max UP:         ${(metrics.maxDriftUp * 100).toFixed(2)}%`);
+        logger.log(`   ├─ Max DOWN:       ${(metrics.maxDriftDown * 100).toFixed(2)}%`);
+        logger.log(`   └─ Band Factor:    ${(metrics.maxDistance * 200).toFixed(2)}%\n`);
+    }
+
+    const outFile = options.outFile
+        ? path.resolve(options.outFile)
+        : defaultChartPath(enrichedMeta);
+
+    logger.log(`Generating chart (${amaResults.length} AMAs)...`);
+    const html = generateHTML(enrichedMeta, candleArrays, amaResults);
+    ensureDir(path.dirname(outFile));
+    fs.writeFileSync(outFile, html, 'utf8');
+
+    logger.log(`\nChart saved: ${path.relative(process.cwd(), outFile)}`);
+    logger.log(`Open:        file://${outFile}`);
+
+    return { dataFile, outFile, amaResults, meta: enrichedMeta, candleArrays };
+}
+
+function run(argv = process.argv.slice(2)) {
+    const { dataFile, outFile, quiet, help } = parseArgs(argv);
+    if (help) { showHelp(); return; }
+
+    if (!quiet) {
+        console.log('════════════════════════════════════════════════');
+        console.log(' Unified Comparison Chart Generator');
+        console.log('════════════════════════════════════════════════');
+        console.log('');
+    }
+
+    try {
+        generateChart({
+            dataFile,
+            outFile,
+            logger: quiet ? { log() {} } : console,
+        });
+    } catch (e: unknown) {
+        console.error('Error:', (e as any)?.message ?? e);
+        process.exitCode = 1;
+    }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    run();
+}
+
+export { DEFAULT_STRATEGIES, generateChart, parseArgs, run, showHelp }
+