dexbot 1.4.15 → 1.4.17

package/analysis/tradingview/README.md

@@ -0,0 +1,161 @@
+# TradingView HTML Exporter
+
+This exporter generates a standalone HTML chart in the `analysis/charts/` folder using the local `uPlot`-based TradingView-style renderer.
+
+## What It Produces
+
+- Log-scale price chart
+- Candle timeframe buttons: `1h`, `4h`, `1d`, `1w`
+- Pair-orientation switcher for `A/B` and `B/A`
+- SMA overlay
+- AMA overlay with explicit `erPeriod`, `fastPeriod`, and `slowPeriod` inputs
+- VWMA overlay
+- Bottom volume panel
+- Crosshair legend with current candle values
+
+## Quick Start
+
+A chart requires candle data. Either pass an explicit candle file or let the exporter resolve a bot's candles and AMA settings:
+
+```bash
+# From an explicit candle JSON file (json source is the default)
+npm run analysis:tradingview -- \
+  --file market_adapter/data/market_adapter_<bot-key>_1h.json
+```
+
+Or with a bot key (see [Bot-Key Usage](#bot-key-usage-recommended) below):
+
+```bash
+npm run analysis:tradingview -- \
+  --source market_adapter \
+  --bot-key <bot-key>
+```
+
+This writes:
+
+```text
+analysis/charts/tradingview_chart.html
+```
+
+> The bare `npm run analysis:tradingview` (no args) errors out — the default `json`
+> source requires `--file`, and the `market_adapter` source requires `--bot-key`.
+
+## Bot-Key Usage (Recommended)
+
+The easiest way to generate a chart for a specific bot. Pass the bot key from `profiles/bots.json` and the exporter automatically resolves the candle file and AMA settings:
+
+```bash
+npm run analysis:tradingview -- \
+  --source market_adapter \
+  --bot-key <bot-key>
+```
+
+This picks up the bot's asset pair, market profile AMA defaults, and candle data from `market_adapter/data/`. AMA is auto-enabled when the bot uses `gridPrice: "ama"` (or ama1-4).
+
+With a custom chart path:
+
+```bash
+npm run analysis:tradingview -- \
+  --source market_adapter \
+  --bot-key <bot-key> \
+  --chart analysis/charts/<pair>_tradingview.html
+```
+
+CLI direct equivalent:
+
+```bash
+tsx analysis/tradingview/analyze_tradingview.ts \
+  --source market_adapter \
+  --bot-key <bot-key>
+```
+
+### How It Works
+
+1. Reads `profiles/bots.json` to find the bot's `assetA`, `assetB`, and `ama` settings.
+2. Resolves the candle file at `market_adapter/data/market_adapter_<bot-key>_1h.json`.
+3. Looks up the matching market profile in `profiles/market_profiles.json` for AMA defaults.
+4. AMA settings priority: bot-specific `ama` object > market profile > constants (AMA3, slowPeriod 82.7).
+
+> The candle file must exist — run the market adapter LP exporter first if needed (see [Getting Blockchain Data](#getting-blockchain-data)).
+
+## From an Explicit Candle File
+
+```bash
+tsx analysis/tradingview/analyze_tradingview.ts \
+  --file market_adapter/data/market_adapter_<bot-key>_1h.json \
+  --chart analysis/charts/<pair>_tradingview.html
+```
+
+Using LP candle files directly:
+
+```bash
+tsx analysis/tradingview/analyze_tradingview.ts \
+  --file market_adapter/data/lp/<pair-folder>/lp_pool_<id>_<interval>.json \
+  --chart analysis/charts/tradingview_chart.html
+```
+
+## Input Format
+
+The exporter accepts candle data in either of these shapes:
+
+- Array rows: `[timestamp_ms, open, high, low, close, volume]`
+- Object rows: `{ time|timestamp|ts, open, high, low, close, volume }`
+
+If you pass a raw JSON file, the runner normalizes the candles before rendering.
+
+## Getting Blockchain Data
+
+Use the market adapter LP exporter to pull blockchain-backed candles before generating the HTML:
+
+```bash
+tsx market_adapter/inputs/fetch_lp_data.ts --pool 133 --precA 4 --precB 5 --interval 1h --lookback 26280h
+```
+
+For date range fetching, use `--start` and `--end` (e.g. `--start 2024-03-06 --end 2025-03-06`).
+
+That writes a JSON file under `market_adapter/data/lp/` which you can then pass to the TradingView exporter.
+
+For manual pool discovery, use `--pool`, `--precA`, and `--precB` instead of `--bot`.
+
+## CLI Flags
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--source <json\|market_adapter>` | Data source type | `json` |
+| `--file <path>` | Candle JSON input file (required for `json` source) | — |
+| `--bot-key <key>` | Bot key for `market_adapter` source | — |
+| `--chart <path>` | Output HTML file | `analysis/charts/tradingview_chart.html` |
+| `--title <text>` | Chart title | auto-generated from meta |
+| `--sma-period <n>` | SMA period | `500` |
+| `--ama-er-period <n>` | AMA ER period | `781` |
+| `--ama-fast-period <n>` | AMA fast period | `5.2` |
+| `--ama-slow-period <n>` | AMA slow period | `82.7` |
+| `--price-scale <log\|linear>` | Price axis scale | `log` |
+| `--scale <log\|linear>` | Alias for `--price-scale` | `log` |
+| `--vwap-bars <n>` | Rolling VWMA window | `500` |
+| `--no-sma` | Disable SMA | — |
+| `--no-ama` | Disable AMA | — |
+| `--no-vwap` | Disable VWMA | — |
+| `--quiet` | Suppress progress logs | — |
+
+## Notes
+
+- The chart uses vendored `uPlot` from `analysis/uplot/` in the generated HTML (no CDN dependency).
+- The displayed indicators are computed from the 1h base candles and then sampled onto the selected timeframe.
+- The current volume-weighted overlay is a rolling `VWMA`, not a session-reset VWAP.
+- SMA is disabled by default.
+- VWMA is disabled by default.
+- AMA is auto-enabled when the bot has `gridPrice: "ama"` (or ama1-4), otherwise disabled by default.
+- The AMA controls start with the bot-specific AMA, then pair-specific entry from `profiles/market_profiles.json` when available, falling back to AMA3 values from `modules/constants.ts`.
+- The AMA `Reset` button restores the HTML defaults, not the browser-stored overrides.
+- The pair switcher inverts the candles client-side, so you can inspect both `A/B` and `B/A` views from one export.
+- Indicator, timeframe, and scale changes are persisted in browser `localStorage` for the generated HTML.
+- The price axis defaults to log base `10`, with a toolbar switch for `Log` / `Linear`.
+- If you regenerate the HTML and then open it later, no CDN access is needed — `uPlot` is loaded from the vendored local copy at `analysis/uplot/`.
+
+## Typical Workflow
+
+1. Pick or generate a candle JSON file.
+2. Run `npm run analysis:tradingview` or call the runner directly.
+3. Open `analysis/charts/tradingview_chart.html` in a browser.
+4. Use the timeframe buttons and indicator controls at the top of the page.

package/analysis/tradingview/analyze_tradingview.ts

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { generateHTML } from './tradingview_uplot_chart_generator.js';
+import { MARKET_ADAPTER } from '../../modules/constants.js';
+import { loadCandleFile } from '../math_utils.js';
+import { getErrorMessage } from '../../modules/utils/errors.js';
+import { toIntervalLabel } from '../../market_adapter/interval_utils.js';
+import { loadBotMeta } from '../bot_key_utils.js';
+import { resolveSource, listAvailableBots } from '../resolve_source.js';
+import { writeChartFile } from '../chart_utils.js';
+import { PATHS } from '../../modules/paths.js';
+'use strict';
+
+
+const DEFAULT_CHART_DIR = PATHS.ANALYSIS.CHARTS_DIR;
+const DEFAULT_CHART_FILE = path.join(DEFAULT_CHART_DIR, 'tradingview_chart.html');
+const DEFAULT_AMA = MARKET_ADAPTER.AMAS.AMA3;
+const AMA_KEYWORDS = new Set(['ama', 'ama1', 'ama2', 'ama3', 'ama4']);
+
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const config: {
+        source: { type: string; config: { filePath: any; botKey?: any } };
+        chartFile: string;
+        title: string | null;
+        priceScale: string;
+        smaPeriod: number;
+        amaErPeriod: number | undefined;
+        amaFastPeriod: number | undefined;
+        amaSlowPeriod: number | undefined;
+        smaEnabled: boolean;
+        amaEnabled: boolean;
+        vwapEnabled: boolean;
+        vwapBars: number;
+        quiet: boolean;
+        listBots: boolean;
+    } = {
+        source: { type: 'market_adapter', config: { botKey: '', filePath: undefined as any } },
+        chartFile: DEFAULT_CHART_FILE,
+        title: null,
+        priceScale: 'log',
+        smaPeriod: 500,
+        amaErPeriod: undefined,
+        amaFastPeriod: undefined,
+        amaSlowPeriod: undefined,
+        smaEnabled: false,
+        amaEnabled: true,
+        vwapEnabled: false,
+        vwapBars: 500,
+        quiet: false,
+        listBots: false,
+    };
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--source') config.source.type = String(args[++i] || 'json');
+        else if (arg === '--file') {
+            config.source.type = 'json';
+            config.source.config.filePath = args[++i];
+        }
+        else if (arg === '--bot-key') config.source.config.botKey = args[++i];
+        else if (arg === '--chart') config.chartFile = args[++i];
+        else if (arg === '--title') config.title = args[++i];
+        else if (arg === '--price-scale' || arg === '--scale') config.priceScale = String(args[++i] || 'log');
+        else if (arg === '--sma-period') config.smaPeriod = Math.max(1, parseInt(args[++i], 10) || 500);
+        else if (arg === '--ama-er-period') config.amaErPeriod = Math.max(1, parseInt(args[++i], 10) || DEFAULT_AMA.erPeriod);
+        else if (arg === '--ama-fast-period') config.amaFastPeriod = Math.max(0.1, parseFloat(args[++i]) || DEFAULT_AMA.fastPeriod);
+        else if (arg === '--ama-slow-period') config.amaSlowPeriod = Math.max(0.1, parseFloat(args[++i]) || DEFAULT_AMA.slowPeriod);
+        else if (arg === '--no-sma') config.smaEnabled = false;
+        else if (arg === '--no-ama') config.amaEnabled = false;
+        else if (arg === '--no-vwap') config.vwapEnabled = false;
+        else if (arg === '--vwap-bars') config.vwapBars = Math.max(24, parseInt(args[++i], 10) || 500);
+        else if (arg === '--list-bots') config.listBots = true;
+        else if (arg === '--quiet') config.quiet = true;
+    }
+
+    return config;
+}
+
+function loadJsonMeta(filePath: any) {
+    if (!filePath || !fs.existsSync(filePath)) return { meta: null, candles: null };
+    return loadCandleFile(filePath);
+}
+
+function inferTitle(meta: any, fallback: string) {
+    const pool = meta?.pool ? `Pool ${String(meta.pool).replace(/^1\.19\./, '')}` : null;
+    const a = meta?.assetA?.symbol || meta?.assetA?.id || null;
+    const b = meta?.assetB?.symbol || meta?.assetB?.id || null;
+    const pair = a && b ? `${a}/${b}` : fallback;
+    const label = pool || pair;
+    const interval = Number(meta?.intervalSeconds) > 0 ? toIntervalLabel(meta.intervalSeconds) : '1h';
+    return `${label} · ${interval} · TradingView`;
+}
+
+async function main() {
+    try {
+        const config = parseArgs();
+
+        if (config.listBots) {
+            listAvailableBots();
+            return;
+        }
+
+        const { source, botKey, amaConfig } = resolveSource({ ...config.source.config, type: config.source.type }, { quiet: config.quiet });
+        if (!config.quiet) console.log(`[TradingView] Loading candles from ${source.name}...`);
+
+        const candles = await source.fetchCandles();
+        if (!Array.isArray(candles) || candles.length === 0) {
+            throw new Error('No candles returned from source');
+        }
+
+        const isJsonSource = config.source.type === 'json';
+        const filePath = config.source.config.filePath;
+        const rawJson = isJsonSource ? loadJsonMeta(filePath) : { meta: null, candles: null };
+        const botMeta = botKey ? loadBotMeta(botKey) : null;
+        const jsonMeta = rawJson.meta || (botMeta ? {
+            assetA: { symbol: botMeta.assetA },
+            assetB: { symbol: botMeta.assetB },
+            intervalSeconds: 3600,
+        } : null);
+        const title = config.title || inferTitle(jsonMeta, path.basename(filePath || 'tradingview'));
+        const hasAmaGridPrice = AMA_KEYWORDS.has(String(botMeta?.gridPrice || '').trim().toLowerCase());
+        const amaEnabled = hasAmaGridPrice ? config.amaEnabled : false;
+
+        const html = generateHTML({
+            candles,
+            meta: jsonMeta || {
+                assetA: { symbol: 'Asset A' },
+                assetB: { symbol: 'Asset B' },
+            },
+            smaPeriod: config.smaPeriod,
+            amaDefaults: {
+                erPeriod: config.amaErPeriod ?? amaConfig.erPeriod,
+                fastPeriod: config.amaFastPeriod ?? amaConfig.fastPeriod,
+                slowPeriod: config.amaSlowPeriod ?? amaConfig.slowPeriod,
+            },
+            smaEnabled: config.smaEnabled,
+            amaEnabled,
+            vwapEnabled: config.vwapEnabled,
+            vwapBars: config.vwapBars,
+            priceScale: config.priceScale === 'linear' ? 'linear' : 'log',
+            defaultTimeframe: '1h',
+            marketAdapter: MARKET_ADAPTER,
+        }, title);
+
+        writeChartFile(config.chartFile, html);
+
+        if (!config.quiet) console.log(`[TradingView] ✓ Chart saved to ${config.chartFile}`);
+    } catch (err: any) {
+        console.error(`[TradingView] Error: ${getErrorMessage(err)}`);
+        process.exit(1);
+    }
+}
+
+main().catch((err: unknown) => { console.error(err); process.exit(1); });
+
+export { main, parseArgs, loadJsonMeta, inferTitle }

package/{dist/analysis/tradingview/tradingview_uplot_chart_generator.js → analysis/tradingview/tradingview_uplot_chart_generator.ts}

@@ -1,3 +1,4 @@
+
 import fs from 'node:fs';
 import { MARKET_ADAPTER } from '../../modules/constants.js';
 import { escapeHtml, serializeJsonForScript } from '../chart_utils.js';
@@ -7,54 +8,48 @@ import { getStorage } from '../../modules/storage/index.js';
 const { readJSON } = getStorage();
 import { getErrorMessage } from '../../modules/utils/errors.js';
 'use strict';
-function inferBaseIntervalSeconds(candles, fallback = 3600) {
-    if (!Array.isArray(candles) || candles.length < 2)
-        return fallback;
-    const deltas = [];
+
+
+function inferBaseIntervalSeconds(candles: any[], fallback: any = 3600) {
+    if (!Array.isArray(candles) || candles.length < 2) return fallback;
+    const deltas: number[] = [];
     for (let i = 1; i < candles.length; i++) {
         const prev = Number(candles[i - 1]?.time);
         const curr = Number(candles[i]?.time);
-        if (!Number.isFinite(prev) || !Number.isFinite(curr))
-            continue;
+        if (!Number.isFinite(prev) || !Number.isFinite(curr)) continue;
         const d = curr - prev;
-        if (d > 0)
-            deltas.push(d);
+        if (d > 0) deltas.push(d);
     }
-    if (deltas.length === 0)
-        return fallback;
-    deltas.sort((a, b) => a - b);
+    if (deltas.length === 0) return fallback;
+    deltas.sort((a: any, b: any) => a - b);
     const mid = Math.floor(deltas.length / 2);
     const med = deltas.length % 2 === 0 ? (deltas[mid - 1] + deltas[mid]) / 2 : deltas[mid];
     return Math.max(60, Math.round(med));
 }
-function loadMarketProfiles(filePath = PATHS.PROFILES.MARKET_PROFILES_JSON) {
-    if (!filePath || !fs.existsSync(filePath))
-        return null;
+
+function loadMarketProfiles(filePath: any = PATHS.PROFILES.MARKET_PROFILES_JSON) {
+    if (!filePath || !fs.existsSync(filePath)) return null;
     try {
         return readJSON(filePath);
-    }
-    catch (err) {
+    } catch (err: any) {
         console.warn(`[WARN] Failed to parse ${filePath}: ${getErrorMessage(err)}. Falling back to built-in AMA defaults.`);
         return null;
     }
 }
-function findMarketProfile(profiles, meta = {}) {
+
+function findMarketProfile(profiles: any, meta: any = {}) {
     const entries = Array.isArray(profiles?.profiles) ? profiles.profiles : [];
-    if (!entries.length)
-        return null;
+    if (!entries.length) return null;
     const assetA = meta.assetA?.symbol || meta.assetA?.id || meta.assetA;
     const assetB = meta.assetB?.symbol || meta.assetB?.id || meta.assetB;
     const intervalSeconds = Number(meta.intervalSeconds);
-    return entries.find((entry) => {
-        if (!entry || typeof entry !== 'object')
-            return false;
+    return entries.find((entry: any) => {
+        if (!entry || typeof entry !== 'object') return false;
         if (assetA && assetB) {
             const matchesPair = (String(entry.assetA) === String(assetA) || String(entry.assetAId) === String(assetA))
                 && (String(entry.assetB) === String(assetB) || String(entry.assetBId) === String(assetB));
-            if (!matchesPair)
-                return false;
-        }
-        else {
+            if (!matchesPair) return false;
+        } else {
             return false;
         }
         if (Number.isFinite(intervalSeconds) && intervalSeconds > 0 && Number(entry.intervalSeconds) !== intervalSeconds) {
@@ -63,7 +58,8 @@ function findMarketProfile(profiles, meta = {}) {
         return true;
     }) || null;
 }
-function resolveAmaDefaults({ meta, data, marketProfiles } = {}) {
+
+function resolveAmaDefaults({ meta, data, marketProfiles }: any = {}) {
     const amaDefaultsSource = MARKET_ADAPTER.AMAS.AMA3;
     const profile = findMarketProfile(marketProfiles, meta);
     const profileAmaKey = profile?.defaultAma && profile.amas && profile.amas[profile.defaultAma]
@@ -81,24 +77,28 @@ function resolveAmaDefaults({ meta, data, marketProfiles } = {}) {
             : Number(source.slowPeriod),
     };
 }
-function generateHTML(data, title = 'TradingView Style Research') {
+
+function generateHTML(data: any, title: any = 'TradingView Style Research') {
     const rawCandles = Array.isArray(data.candles) ? data.candles : [];
     const candles = rawCandles.map(normalizeCandle).filter(Boolean);
-    if (candles.length === 0)
-        throw new Error('No candle data in input');
+    if (candles.length === 0) throw new Error('No candle data in input');
+
     const meta = data.meta || {};
     const baseIntervalSeconds = Number(meta.intervalSeconds) > 0
         ? Number(meta.intervalSeconds)
         : inferBaseIntervalSeconds(candles, 3600);
+
     const timeframes = [
         { label: '1h', seconds: 3600 },
         { label: '4h', seconds: 14400 },
         { label: '1d', seconds: 86400 },
         { label: '1w', seconds: 604800 },
-    ].map((item) => ({ ...item, enabled: item.seconds >= baseIntervalSeconds }));
-    const defaultTimeframe = timeframes.find((item) => item.label === data.defaultTimeframe && item.enabled)
-        || timeframes.find((item) => item.enabled)
+    ].map((item: any) => ({ ...item, enabled: item.seconds >= baseIntervalSeconds }));
+
+    const defaultTimeframe = timeframes.find((item: any) => item.label === data.defaultTimeframe && item.enabled)
+        || timeframes.find((item: any) => item.enabled)
         || timeframes[0];
+
     const marketProfiles = data.marketProfiles || loadMarketProfiles();
     const defaultAmaConfig = resolveAmaDefaults({ meta, data, marketProfiles });
     const defaults = {
@@ -110,6 +110,7 @@ function generateHTML(data, title = 'TradingView Style Research') {
         vwapBars: Math.max(5, Math.round(data.vwapBars ?? 500)),
         priceScale: data.priceScale === 'linear' ? 'linear' : 'log',
     };
+
     const assetLabelA = meta.assetA?.symbol || meta.assetA?.id || 'Asset A';
     const assetLabelB = meta.assetB?.symbol || meta.assetB?.id || 'Asset B';
     const pairLabelNormal = `${assetLabelA}/${assetLabelB}`;
@@ -119,6 +120,7 @@ function generateHTML(data, title = 'TradingView Style Research') {
         ? `${Math.round(baseIntervalSeconds / 86400)}d`
         : `${Math.round(baseIntervalSeconds / 3600)}h`;
     const defaultPairMode = data.defaultPairMode === 'inverse' ? 'inverse' : 'normal';
+
     const payload = {
         candles,
         timeframes,
@@ -139,6 +141,7 @@ function generateHTML(data, title = 'TradingView Style Research') {
         intervalLabel,
         amaDefaultsSource: marketProfiles ? 'market_profiles' : 'constants',
     };
+
     return `<!doctype html>
 <html lang="en">
 <head>
@@ -411,7 +414,7 @@ function generateHTML(data, title = 'TradingView Style Research') {
             </div>
             <div id="toolbar">
                 <div class="group" id="tf-group">
-                    ${timeframes.map((item) => `<button class="time-btn${item.label === defaultTimeframe.label ? ' active' : ''}" data-timeframe="${escapeHtml(item.label)}"${item.enabled ? '' : ' disabled'}>${escapeHtml(item.label)}</button>`).join('')}
+                    ${timeframes.map((item: any) => `<button class="time-btn${item.label === defaultTimeframe.label ? ' active' : ''}" data-timeframe="${escapeHtml(item.label)}"${item.enabled ? '' : ' disabled'}>${escapeHtml(item.label)}</button>`).join('')}
                 </div>
                 <div class="group">
                     <div class="indicator">
@@ -1710,5 +1713,6 @@ function generateHTML(data, title = 'TradingView Style Research') {
 </body>
 </html>`;
 }
-export { generateHTML, normalizeCandle, loadMarketProfiles };
-//# sourceMappingURL=tradingview_uplot_chart_generator.js.map
+
+export { generateHTML, normalizeCandle, loadMarketProfiles }
+