dexbot 1.6.9 → 1.6.11
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +34 -0
- package/README.md +1 -0
- package/analysis/README.md +50 -12
- package/analysis/bot_fitting/README.md +12 -0
- package/analysis/tradingview/README.md +15 -10
- package/analysis/trend_detection/DYNAMIC_WEIGHT_RESEARCH.md +10 -36
- package/analysis/trend_detection/README.md +31 -0
- package/claw/modules/chain_queries.ts +9 -4
- package/claw/modules/claw_bridge.ts +9 -9
- package/claw/package.json +1 -1
- package/claw/runtimes/openclaw-plugin/openclaw.plugin.json +1 -1
- package/claw/runtimes/openclaw-plugin/package.json +1 -1
- package/dist/analysis/account_resolver.js +13 -1
- package/dist/analysis/ama_fitting/optimizer_high_resolution.js +2 -1
- package/dist/analysis/analyze_dynamic_weight.js +0 -3
- package/dist/analysis/bot_fitting/backtest_ama_sweep.js +52 -8
- package/dist/analysis/bot_fitting/backtest_bot_fitting.js +68 -10
- package/dist/analysis/bot_fitting/backtest_lookback_drawdown.d.ts +21 -0
- package/dist/analysis/bot_fitting/backtest_lookback_drawdown.js +315 -0
- package/dist/analysis/bot_key_utils.js +17 -17
- package/dist/analysis/fills_cache.d.ts +64 -0
- package/dist/analysis/fills_cache.js +254 -0
- package/dist/analysis/fills_source.js +5 -2
- package/dist/analysis/pnl_report.d.ts +39 -0
- package/dist/analysis/pnl_report.js +325 -0
- package/dist/analysis/resolve_source.d.ts +0 -1
- package/dist/analysis/trade_profitability.d.ts +11 -2
- package/dist/analysis/trade_profitability.js +187 -61
- package/dist/analysis/tradingview/analyze_tradingview.d.ts +0 -3
- package/dist/analysis/tradingview/analyze_tradingview.js +6 -19
- package/dist/analysis/tradingview/grid_reset_config.d.ts +2 -0
- package/dist/analysis/tradingview/grid_reset_config.js +18 -1
- package/dist/analysis/tradingview/grid_reset_sim.d.ts +12 -1
- package/dist/analysis/tradingview/grid_reset_sim.js +60 -11
- package/dist/analysis/tradingview/tradingview_uplot_chart_generator.js +180 -33
- package/dist/analysis/trend_detection/backtest_ama_slope_huber.d.ts +102 -0
- package/dist/analysis/trend_detection/backtest_ama_slope_huber.js +725 -0
- package/dist/analysis/trend_detection/dynamic_weight_chart_generator.js +29 -110
- package/dist/analysis/trend_detection/huber_scale_variants.d.ts +34 -0
- package/dist/analysis/trend_detection/huber_scale_variants.js +176 -0
- package/dist/dexbot.js +19 -11
- package/dist/market_adapter/core/market_adapter_service.d.ts +15 -0
- package/dist/market_adapter/core/market_adapter_service.js +64 -5
- package/dist/market_adapter/core/strategies/ama.d.ts +1 -1
- package/dist/market_adapter/core/strategies/ama.js +5 -28
- package/dist/market_adapter/core/strategies/ama_slope_model.d.ts +2 -2
- package/dist/market_adapter/core/strategies/ama_slope_model.js +12 -10
- package/dist/market_adapter/core/strategies/dynamic_weight_series.d.ts +41 -14
- package/dist/market_adapter/core/strategies/dynamic_weight_series.js +138 -30
- package/dist/market_adapter/inputs/fetch_cex_synthetic_data.js +1 -2
- package/dist/market_adapter/log_format.js +1 -2
- package/dist/market_adapter/lp_chart_strategy_loader.js +2 -1
- package/dist/market_adapter/market_adapter.d.ts +0 -1
- package/dist/market_adapter/market_adapter.js +2 -27
- package/dist/market_adapter/utils/chain.d.ts +1 -1
- package/dist/market_adapter/utils/chain.js +8 -6
- package/dist/modules/account_bots.js +5 -4
- package/dist/modules/bitshares-native/resolvers.js +5 -0
- package/dist/modules/bot_settings.js +13 -1
- package/dist/modules/chain_orders.js +2 -1
- package/dist/modules/constants.d.ts +9 -1
- package/dist/modules/constants.js +55 -9
- package/dist/modules/credential_policy.js +4 -1
- package/dist/modules/credit_runtime.js +5 -1
- package/dist/modules/dexbot_maintenance_runtime.js +12 -0
- package/dist/modules/order/accounting.js +25 -0
- package/dist/modules/order/format.d.ts +35 -15
- package/dist/modules/order/format.js +62 -16
- package/dist/modules/order/manager.d.ts +1 -0
- package/dist/modules/order/manager.js +22 -1
- package/dist/modules/order/sync_engine.js +15 -1
- package/dist/modules/order/utils/order.d.ts +21 -1
- package/dist/modules/order/utils/order.js +80 -2
- package/dist/modules/order/utils/system.js +11 -1
- package/dist/modules/paths.d.ts +2 -0
- package/dist/modules/paths.js +2 -0
- package/dist/modules/utils/asset_symbols.d.ts +59 -0
- package/dist/modules/utils/asset_symbols.js +128 -0
- package/dist/modules/utils/time_range.d.ts +15 -0
- package/dist/modules/utils/time_range.js +18 -0
- package/dist/scripts/analyze-credit.js +10 -7
- package/dist/scripts/analyze-orders.js +1 -44
- package/dist/scripts/chart_command.js +15 -8
- package/dist/scripts/pnl.d.ts +3 -0
- package/dist/scripts/pnl.js +40 -0
- package/dist/scripts/verify-browser-bundle.js +8 -0
- package/dist/unlock.js +34 -0
- package/docs/DEXBOT_COMPARISON.md +3 -3
- package/docs/EVOLUTION.md +12 -10
- package/docs/FUND_MOVEMENT_AND_ACCOUNTING.md +1 -1
- package/docs/GRID_RECALCULATION.md +33 -17
- package/docs/README.md +2 -2
- package/docs/WORKFLOW.md +1 -0
- package/market_adapter/README.md +6 -28
- package/package.json +1 -1
- package/scripts/README.md +14 -0
|
@@ -8,6 +8,7 @@ import { parseJsonWithComments } from '../modules/order/utils/system.js';
|
|
|
8
8
|
import { MARKET_ADAPTER } from '../modules/constants.js';
|
|
9
9
|
import { loadMarketProfiles } from './tradingview/tradingview_uplot_chart_generator.js';
|
|
10
10
|
import { sanitizeKey } from '../modules/utils/sanitize_key.js';
|
|
11
|
+
import { isSameAssetSymbol, canonicalizeBotAssetSymbols } from '../modules/utils/asset_symbols.js';
|
|
11
12
|
// Single source of truth for bot keys (named AND unnamed bots) so analysis
|
|
12
13
|
// tools resolve the same files production writes.
|
|
13
14
|
import { createBotKey } from '../modules/account_orders.js';
|
|
@@ -70,11 +71,17 @@ function loadBotMeta(botKey, filePath = PATHS.PROFILES.BOTS_JSON) {
|
|
|
70
71
|
if (!botKey)
|
|
71
72
|
return null;
|
|
72
73
|
const normalizedKey = String(botKey).toLowerCase();
|
|
74
|
+
// Analysis-side twin of modules/bot_settings.normalizeBotEntry: hand out
|
|
75
|
+
// the pair in BitShares' canonical UPPERCASE so a hand-edited lowercase
|
|
76
|
+
// bots.json cannot leak into titles, overlays or symbol comparisons. The
|
|
77
|
+
// same single definition of the symbol-carrying keys is reused (no second
|
|
78
|
+
// copy of the rule), and persistBotAccountId patches the raw file by
|
|
79
|
+
// index, so nothing here can rewrite the operator's JSON.
|
|
73
80
|
const exact = entries.find((bot, index) => computeBotKey(bot, index) === normalizedKey);
|
|
74
81
|
if (exact)
|
|
75
|
-
return exact;
|
|
82
|
+
return canonicalizeBotAssetSymbols(exact);
|
|
76
83
|
const loose = entries.find((bot) => sanitizeKey(bot?.name) === normalizedKey.replace(/-\d+$/, ''));
|
|
77
|
-
return loose
|
|
84
|
+
return loose ? canonicalizeBotAssetSymbols(loose) : null;
|
|
78
85
|
}
|
|
79
86
|
/**
|
|
80
87
|
* Locate the source span of the entryIndex-th object literal inside the
|
|
@@ -452,20 +459,11 @@ function findBotKeyByAccountRef(ref, filePath = PATHS.PROFILES.BOTS_JSON) {
|
|
|
452
459
|
}
|
|
453
460
|
function resolveAmaConfig(botKey) {
|
|
454
461
|
const botMeta = loadBotMeta(botKey);
|
|
455
|
-
// Unknown bot key: fall back to the global erSmoothPeriod default (same
|
|
456
|
-
// resolution path production uses) instead of forcing 0 — a typo'd
|
|
457
|
-
// --bot-key must not silently research with different ER smoothing.
|
|
458
462
|
if (!botMeta)
|
|
459
|
-
return { ...MARKET_ADAPTER.AMAS.AMA3
|
|
463
|
+
return { ...MARKET_ADAPTER.AMAS.AMA3 };
|
|
460
464
|
const rawGridPrice = String(botMeta?.gridPrice || '').trim().toLowerCase();
|
|
461
465
|
const isAmaKeyword = AMA_KEYWORDS.has(rawGridPrice);
|
|
462
|
-
// erSmoothPeriod: bot.ama inline > global default (matches production resolveErSmoothPeriodForBot)
|
|
463
466
|
const botAmaInline = (botMeta?.ama && typeof botMeta.ama === 'object') ? botMeta.ama : null;
|
|
464
|
-
const rawErSmooth = botAmaInline && Object.prototype.hasOwnProperty.call(botAmaInline, 'erSmoothPeriod')
|
|
465
|
-
? Number(botAmaInline.erSmoothPeriod)
|
|
466
|
-
: Number(MARKET_ADAPTER.AMA_ER_SMOOTH_FAST_PERIOD);
|
|
467
|
-
const erSmoothPeriod = rawErSmooth === 0 ? 0
|
|
468
|
-
: (Number.isFinite(rawErSmooth) && rawErSmooth >= 1 ? rawErSmooth : 0);
|
|
469
467
|
// Priority: inline bot.ama overrides market profile for analysis visibility.
|
|
470
468
|
// Production inverts this (profiles first, inline as fallback — market_adapter.ts:694-730).
|
|
471
469
|
if (botAmaInline) {
|
|
@@ -473,7 +471,6 @@ function resolveAmaConfig(botKey) {
|
|
|
473
471
|
erPeriod: Number(botAmaInline.erPeriod),
|
|
474
472
|
fastPeriod: Number(botAmaInline.fastPeriod),
|
|
475
473
|
slowPeriod: Number(botAmaInline.slowPeriod),
|
|
476
|
-
erSmoothPeriod,
|
|
477
474
|
};
|
|
478
475
|
if (isAmaKeyword) {
|
|
479
476
|
const key = rawGridPrice === 'ama' ? DEFAULT_AMA_KEY : rawGridPrice.toUpperCase();
|
|
@@ -501,9 +498,12 @@ function resolveAmaConfig(botKey) {
|
|
|
501
498
|
return cfg;
|
|
502
499
|
}
|
|
503
500
|
const marketProfiles = loadMarketProfiles();
|
|
501
|
+
// Pair match is case-insensitive: market_profiles.json and bots.json are
|
|
502
|
+
// hand-edited, and a case-only difference must not silently drop the
|
|
503
|
+
// profile (a strict === here made the AMA/grid config vanish).
|
|
504
504
|
const selectedProfile = marketProfiles?.profiles
|
|
505
|
-
? marketProfiles.profiles.find((entry) =>
|
|
506
|
-
|
|
505
|
+
? marketProfiles.profiles.find((entry) => isSameAssetSymbol(entry.assetA, botMeta.assetA) &&
|
|
506
|
+
isSameAssetSymbol(entry.assetB, botMeta.assetB) &&
|
|
507
507
|
Number(entry.intervalSeconds) === 3600)
|
|
508
508
|
: null;
|
|
509
509
|
if (selectedProfile?.amas) {
|
|
@@ -515,14 +515,14 @@ function resolveAmaConfig(botKey) {
|
|
|
515
515
|
const fromBuiltin = BUILTIN_AMAS[requestedKey] || BUILTIN_AMAS[fallbackKey];
|
|
516
516
|
const base = fromProfile || fromBuiltin;
|
|
517
517
|
if (base) {
|
|
518
|
-
return { erPeriod: base.erPeriod, fastPeriod: base.fastPeriod, slowPeriod: base.slowPeriod
|
|
518
|
+
return { erPeriod: base.erPeriod, fastPeriod: base.fastPeriod, slowPeriod: base.slowPeriod };
|
|
519
519
|
}
|
|
520
520
|
}
|
|
521
521
|
const key = isAmaKeyword
|
|
522
522
|
? (rawGridPrice === 'ama' ? DEFAULT_AMA_KEY : rawGridPrice.toUpperCase())
|
|
523
523
|
: DEFAULT_AMA_KEY;
|
|
524
524
|
const builtin = BUILTIN_AMAS[key] || MARKET_ADAPTER.AMAS.AMA3;
|
|
525
|
-
return { erPeriod: builtin.erPeriod, fastPeriod: builtin.fastPeriod, slowPeriod: builtin.slowPeriod
|
|
525
|
+
return { erPeriod: builtin.erPeriod, fastPeriod: builtin.fastPeriod, slowPeriod: builtin.slowPeriod };
|
|
526
526
|
}
|
|
527
527
|
function resolveAmaKey(botKey) {
|
|
528
528
|
const botMeta = loadBotMeta(botKey);
|
|
@@ -0,0 +1,64 @@
|
|
|
1
|
+
import { FillRecord } from './fills_source.js';
|
|
2
|
+
/** How long after a query its trailing fills may still be late-indexed. */
|
|
3
|
+
declare const TAIL_SETTLE_LAG_MS: number;
|
|
4
|
+
/** Upper bound on spans persisted per shard (keeps coverage bookkeeping small). */
|
|
5
|
+
declare const MAX_COVERAGE_SPANS = 64;
|
|
6
|
+
interface QueriedRange {
|
|
7
|
+
gte: number;
|
|
8
|
+
lte: number;
|
|
9
|
+
at: number | null;
|
|
10
|
+
}
|
|
11
|
+
interface Span {
|
|
12
|
+
gte: number;
|
|
13
|
+
lte: number;
|
|
14
|
+
}
|
|
15
|
+
interface FillsShard {
|
|
16
|
+
meta: {
|
|
17
|
+
accountId: string;
|
|
18
|
+
fetchedAt: string;
|
|
19
|
+
queriedRanges: QueriedRange[];
|
|
20
|
+
};
|
|
21
|
+
fills: FillRecord[];
|
|
22
|
+
}
|
|
23
|
+
interface FetchFillsOptions {
|
|
24
|
+
/** Override the cache root (tests). */
|
|
25
|
+
cacheDir?: string;
|
|
26
|
+
/** Ignore coverage and re-query the requested range (still merges results). */
|
|
27
|
+
refresh?: boolean;
|
|
28
|
+
/** Fixed "now" for deterministic settle math (tests). */
|
|
29
|
+
nowMs?: number;
|
|
30
|
+
/** Injected range fetcher (tests); defaults to the real Kibana query. */
|
|
31
|
+
fetchRange?: (gteIso: string, lteIso: string) => Promise<FillRecord[]>;
|
|
32
|
+
quiet?: boolean;
|
|
33
|
+
}
|
|
34
|
+
declare function shardKeyForTimestamp(tsMs: number): string;
|
|
35
|
+
declare function shardBoundsForKey(key: string): {
|
|
36
|
+
start: number;
|
|
37
|
+
end: number;
|
|
38
|
+
};
|
|
39
|
+
declare function shardKeysForRange(gteMs: number, lteMs: number): string[];
|
|
40
|
+
declare function basePathFor(cacheDir: string, accountId: string): string;
|
|
41
|
+
declare function shardPathFor(basePath: string, shardKey: string): string;
|
|
42
|
+
/** Sort, merge overlapping/adjacent same-`at` spans, cap the list length. */
|
|
43
|
+
declare function normalizeQueried(ranges: QueriedRange[]): QueriedRange[];
|
|
44
|
+
/** Record a freshly queried span, dropping older spans it fully supersedes. */
|
|
45
|
+
declare function addCoverage(queried: QueriedRange[], span: Span, atMs: number): QueriedRange[];
|
|
46
|
+
/**
|
|
47
|
+
* Portions of queried spans that are safe to reuse: the part up to
|
|
48
|
+
* `at - TAIL_SETTLE_LAG_MS`. A span with an unknown `at` certifies nothing.
|
|
49
|
+
*/
|
|
50
|
+
declare function trustedSegments(queried: QueriedRange[], nowMs: number): Span[];
|
|
51
|
+
/** `span` minus the union of `covered` (both as inclusive ms ranges). */
|
|
52
|
+
declare function subtractRanges(span: Span, covered: Span[]): Span[];
|
|
53
|
+
declare function fillKey(f: FillRecord): string;
|
|
54
|
+
/** Union two fill lists, deduped by the unique operation identity. */
|
|
55
|
+
declare function mergeFills(existing: FillRecord[], incoming: FillRecord[]): FillRecord[];
|
|
56
|
+
/**
|
|
57
|
+
* Fetch every fill_order for an account over [gteIso, lteIso], reusing cached
|
|
58
|
+
* month shards and querying only their missing spans. Falls back to a direct
|
|
59
|
+
* fetch when the range is malformed.
|
|
60
|
+
*/
|
|
61
|
+
declare function fetchFillsCached(config: any, accountId: string, gteIso: string, lteIso: string, options?: FetchFillsOptions): Promise<FillRecord[]>;
|
|
62
|
+
export { fetchFillsCached, shardKeyForTimestamp, shardBoundsForKey, shardKeysForRange, basePathFor, shardPathFor, normalizeQueried, addCoverage, trustedSegments, subtractRanges, mergeFills, fillKey, TAIL_SETTLE_LAG_MS, MAX_COVERAGE_SPANS, };
|
|
63
|
+
export type { QueriedRange, FillsShard, FetchFillsOptions };
|
|
64
|
+
//# sourceMappingURL=fills_cache.d.ts.map
|
|
@@ -0,0 +1,254 @@
|
|
|
1
|
+
'use strict';
|
|
2
|
+
/**
|
|
3
|
+
* FILLS CACHE — persistent calendar-month shard cache for per-account
|
|
4
|
+
* `fill_order` fetches (`analysis/fills_source.ts`).
|
|
5
|
+
*
|
|
6
|
+
* `dexbot pnl` re-queries Kibana on every run; this layer lets a settled month
|
|
7
|
+
* be answered from disk. It mirrors the design principles of the candle cache
|
|
8
|
+
* (`market_adapter/inputs/window_cache.ts`) but is intentionally fills-specific:
|
|
9
|
+
* fills are sparse point events, so reuse is driven purely by recorded query
|
|
10
|
+
* COVERAGE (a month queried and found empty is still covered), not by a
|
|
11
|
+
* bucket-by-bucket presence grid.
|
|
12
|
+
*
|
|
13
|
+
* Storage: `<cacheDir>/fills/<accountId>.shard_YYYY-MM.json`, one file per UTC
|
|
14
|
+
* calendar month, holding `{ meta: { accountId, fetchedAt, queriedRanges },
|
|
15
|
+
* fills }`. `queriedRanges` records the spans actually queried together with
|
|
16
|
+
* `at` (when the query ran).
|
|
17
|
+
*
|
|
18
|
+
* Reuse rule: a recorded span is trusted only up to `at - TAIL_SETTLE_LAG_MS`,
|
|
19
|
+
* because Kibana indexes fills with a lag — a query cannot certify the last
|
|
20
|
+
* few hours before it ran. The unsettled tail is therefore re-queried on the
|
|
21
|
+
* next run (incremental refresh), while older settled spans are reused with
|
|
22
|
+
* zero queries and zero writes. `refresh` (from `--refresh-account`) ignores
|
|
23
|
+
* coverage and re-queries the whole requested range, but still merges what it
|
|
24
|
+
* gets back so a fresh query can never drop fills outside the requested span.
|
|
25
|
+
*/
|
|
26
|
+
import path from 'node:path';
|
|
27
|
+
import { getStorage } from '../modules/storage/index.js';
|
|
28
|
+
import { PATHS } from '../modules/paths.js';
|
|
29
|
+
import { writeJsonAtomic } from '../market_adapter/utils/atomic_write.js';
|
|
30
|
+
import { fetchAllFills } from './fills_source.js';
|
|
31
|
+
const storage = getStorage();
|
|
32
|
+
const { readJSON } = storage;
|
|
33
|
+
/** How long after a query its trailing fills may still be late-indexed. */
|
|
34
|
+
const TAIL_SETTLE_LAG_MS = 6 * 3600 * 1000;
|
|
35
|
+
/** Upper bound on spans persisted per shard (keeps coverage bookkeeping small). */
|
|
36
|
+
const MAX_COVERAGE_SPANS = 64;
|
|
37
|
+
const SHARD_EXT = '.json';
|
|
38
|
+
const SHARD_MARKER = '.shard_';
|
|
39
|
+
function shardKeyForTimestamp(tsMs) {
|
|
40
|
+
const d = new Date(Number(tsMs));
|
|
41
|
+
return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, '0')}`;
|
|
42
|
+
}
|
|
43
|
+
function shardBoundsForKey(key) {
|
|
44
|
+
const parts = String(key).split('-').map(Number);
|
|
45
|
+
const start = Date.UTC(parts[0], parts[1] - 1, 1);
|
|
46
|
+
const end = parts[1] === 12 ? Date.UTC(parts[0] + 1, 0, 1) : Date.UTC(parts[0], parts[1], 1);
|
|
47
|
+
return { start, end };
|
|
48
|
+
}
|
|
49
|
+
function shardKeysForRange(gteMs, lteMs) {
|
|
50
|
+
const keys = [];
|
|
51
|
+
const cursor = new Date(Date.UTC(new Date(gteMs).getUTCFullYear(), new Date(gteMs).getUTCMonth(), 1));
|
|
52
|
+
const last = new Date(lteMs);
|
|
53
|
+
while (cursor <= last) {
|
|
54
|
+
keys.push(shardKeyForTimestamp(cursor.getTime()));
|
|
55
|
+
cursor.setUTCMonth(cursor.getUTCMonth() + 1);
|
|
56
|
+
}
|
|
57
|
+
return keys;
|
|
58
|
+
}
|
|
59
|
+
function accountFileBase(accountId) {
|
|
60
|
+
const s = String(accountId ?? '').trim();
|
|
61
|
+
if (/^1\.2\.\d+$/.test(s))
|
|
62
|
+
return s;
|
|
63
|
+
return s.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'account';
|
|
64
|
+
}
|
|
65
|
+
function basePathFor(cacheDir, accountId) {
|
|
66
|
+
return path.join(cacheDir, 'fills', `${accountFileBase(accountId)}${SHARD_EXT}`);
|
|
67
|
+
}
|
|
68
|
+
function shardPathFor(basePath, shardKey) {
|
|
69
|
+
const parsed = path.parse(basePath);
|
|
70
|
+
return path.join(parsed.dir, `${parsed.name}${SHARD_MARKER}${shardKey}${parsed.ext}`);
|
|
71
|
+
}
|
|
72
|
+
function readShard(shardFile, accountId) {
|
|
73
|
+
try {
|
|
74
|
+
const parsed = readJSON(shardFile);
|
|
75
|
+
if (!parsed || parsed.meta?.accountId !== accountId)
|
|
76
|
+
return null;
|
|
77
|
+
if (!Array.isArray(parsed.fills))
|
|
78
|
+
return null;
|
|
79
|
+
return {
|
|
80
|
+
meta: {
|
|
81
|
+
accountId,
|
|
82
|
+
fetchedAt: String(parsed.meta?.fetchedAt || ''),
|
|
83
|
+
queriedRanges: Array.isArray(parsed.meta?.queriedRanges) ? parsed.meta.queriedRanges : [],
|
|
84
|
+
},
|
|
85
|
+
fills: parsed.fills,
|
|
86
|
+
};
|
|
87
|
+
}
|
|
88
|
+
catch (_) {
|
|
89
|
+
return null;
|
|
90
|
+
}
|
|
91
|
+
}
|
|
92
|
+
/** Sort, merge overlapping/adjacent same-`at` spans, cap the list length. */
|
|
93
|
+
function normalizeQueried(ranges) {
|
|
94
|
+
const clean = (ranges || [])
|
|
95
|
+
.filter((q) => q && Number.isFinite(Number(q.gte)) && Number.isFinite(Number(q.lte)) && Number(q.lte) >= Number(q.gte))
|
|
96
|
+
.map((q) => ({
|
|
97
|
+
gte: Number(q.gte),
|
|
98
|
+
lte: Number(q.lte),
|
|
99
|
+
at: Number.isFinite(Number(q.at)) ? Number(q.at) : null,
|
|
100
|
+
}))
|
|
101
|
+
.sort((a, b) => a.gte - b.gte || a.lte - b.lte);
|
|
102
|
+
const merged = [];
|
|
103
|
+
for (const q of clean) {
|
|
104
|
+
const top = merged[merged.length - 1];
|
|
105
|
+
if (top && q.gte <= top.lte + 1 && top.at === q.at) {
|
|
106
|
+
if (q.lte > top.lte)
|
|
107
|
+
top.lte = q.lte;
|
|
108
|
+
}
|
|
109
|
+
else {
|
|
110
|
+
merged.push({ ...q });
|
|
111
|
+
}
|
|
112
|
+
}
|
|
113
|
+
if (merged.length > MAX_COVERAGE_SPANS)
|
|
114
|
+
merged.splice(0, merged.length - MAX_COVERAGE_SPANS);
|
|
115
|
+
return merged;
|
|
116
|
+
}
|
|
117
|
+
/** Record a freshly queried span, dropping older spans it fully supersedes. */
|
|
118
|
+
function addCoverage(queried, span, atMs) {
|
|
119
|
+
const kept = queried.filter((q) => !(q.gte >= span.gte && q.lte <= span.lte));
|
|
120
|
+
return normalizeQueried([...kept, { gte: span.gte, lte: span.lte, at: atMs }]);
|
|
121
|
+
}
|
|
122
|
+
function mergeSpans(spans) {
|
|
123
|
+
const sorted = [...spans].sort((a, b) => a.gte - b.gte || a.lte - b.lte);
|
|
124
|
+
const merged = [];
|
|
125
|
+
for (const s of sorted) {
|
|
126
|
+
const top = merged[merged.length - 1];
|
|
127
|
+
if (top && s.gte <= top.lte + 1) {
|
|
128
|
+
if (s.lte > top.lte)
|
|
129
|
+
top.lte = s.lte;
|
|
130
|
+
}
|
|
131
|
+
else {
|
|
132
|
+
merged.push({ ...s });
|
|
133
|
+
}
|
|
134
|
+
}
|
|
135
|
+
return merged;
|
|
136
|
+
}
|
|
137
|
+
/**
|
|
138
|
+
* Portions of queried spans that are safe to reuse: the part up to
|
|
139
|
+
* `at - TAIL_SETTLE_LAG_MS`. A span with an unknown `at` certifies nothing.
|
|
140
|
+
*/
|
|
141
|
+
function trustedSegments(queried, nowMs) {
|
|
142
|
+
const segs = [];
|
|
143
|
+
for (const q of queried) {
|
|
144
|
+
if (q.at == null)
|
|
145
|
+
continue;
|
|
146
|
+
const end = Math.min(q.lte, q.at - TAIL_SETTLE_LAG_MS, nowMs - TAIL_SETTLE_LAG_MS);
|
|
147
|
+
if (end >= q.gte)
|
|
148
|
+
segs.push({ gte: q.gte, lte: end });
|
|
149
|
+
}
|
|
150
|
+
return mergeSpans(segs);
|
|
151
|
+
}
|
|
152
|
+
/** `span` minus the union of `covered` (both as inclusive ms ranges). */
|
|
153
|
+
function subtractRanges(span, covered) {
|
|
154
|
+
let parts = [{ ...span }];
|
|
155
|
+
for (const c of mergeSpans(covered)) {
|
|
156
|
+
const next = [];
|
|
157
|
+
for (const p of parts) {
|
|
158
|
+
if (c.lte < p.gte || c.gte > p.lte) {
|
|
159
|
+
next.push(p);
|
|
160
|
+
continue;
|
|
161
|
+
}
|
|
162
|
+
if (c.gte > p.gte)
|
|
163
|
+
next.push({ gte: p.gte, lte: Math.min(p.lte, c.gte - 1) });
|
|
164
|
+
if (c.lte < p.lte)
|
|
165
|
+
next.push({ gte: Math.max(p.gte, c.lte + 1), lte: p.lte });
|
|
166
|
+
}
|
|
167
|
+
parts = next.filter(p => p.lte >= p.gte);
|
|
168
|
+
if (parts.length === 0)
|
|
169
|
+
break;
|
|
170
|
+
}
|
|
171
|
+
return parts;
|
|
172
|
+
}
|
|
173
|
+
function fillKey(f) {
|
|
174
|
+
return `${f.blockNum}:${f.opNum}`;
|
|
175
|
+
}
|
|
176
|
+
function compareFills(a, b) {
|
|
177
|
+
if (a.time !== b.time)
|
|
178
|
+
return a.time < b.time ? -1 : 1;
|
|
179
|
+
if (a.blockNum !== b.blockNum)
|
|
180
|
+
return a.blockNum - b.blockNum;
|
|
181
|
+
return a.opNum - b.opNum;
|
|
182
|
+
}
|
|
183
|
+
/** Union two fill lists, deduped by the unique operation identity. */
|
|
184
|
+
function mergeFills(existing, incoming) {
|
|
185
|
+
const byKey = new Map();
|
|
186
|
+
for (const f of existing)
|
|
187
|
+
byKey.set(fillKey(f), f);
|
|
188
|
+
for (const f of incoming)
|
|
189
|
+
byKey.set(fillKey(f), f);
|
|
190
|
+
return [...byKey.values()].sort(compareFills);
|
|
191
|
+
}
|
|
192
|
+
/**
|
|
193
|
+
* Fetch every fill_order for an account over [gteIso, lteIso], reusing cached
|
|
194
|
+
* month shards and querying only their missing spans. Falls back to a direct
|
|
195
|
+
* fetch when the range is malformed.
|
|
196
|
+
*/
|
|
197
|
+
async function fetchFillsCached(config, accountId, gteIso, lteIso, options = {}) {
|
|
198
|
+
const gteMs = Date.parse(gteIso);
|
|
199
|
+
const lteMs = Date.parse(lteIso);
|
|
200
|
+
const doFetch = options.fetchRange ?? ((gte, lte) => fetchAllFills(config, accountId, gte, lte));
|
|
201
|
+
if (!Number.isFinite(gteMs) || !Number.isFinite(lteMs) || lteMs < gteMs) {
|
|
202
|
+
return doFetch(gteIso, lteIso);
|
|
203
|
+
}
|
|
204
|
+
const nowMs = options.nowMs ?? Date.now();
|
|
205
|
+
const cacheDir = options.cacheDir ?? PATHS.ANALYSIS.CACHE_DIR;
|
|
206
|
+
const basePath = basePathFor(cacheDir, accountId);
|
|
207
|
+
const collected = new Map();
|
|
208
|
+
let fetchedSpans = 0;
|
|
209
|
+
let queriedFills = 0;
|
|
210
|
+
let reusedMonths = 0;
|
|
211
|
+
for (const key of shardKeysForRange(gteMs, lteMs)) {
|
|
212
|
+
const { start, end } = shardBoundsForKey(key);
|
|
213
|
+
const shardGte = Math.max(gteMs, start);
|
|
214
|
+
const shardLte = Math.min(lteMs, end - 1);
|
|
215
|
+
if (shardLte < shardGte)
|
|
216
|
+
continue;
|
|
217
|
+
const shardFile = shardPathFor(basePath, key);
|
|
218
|
+
const shard = readShard(shardFile, accountId);
|
|
219
|
+
const existingQueried = shard ? normalizeQueried(shard.meta.queriedRanges) : [];
|
|
220
|
+
const trusted = options.refresh ? [] : trustedSegments(existingQueried, nowMs);
|
|
221
|
+
const missing = subtractRanges({ gte: shardGte, lte: shardLte }, trusted);
|
|
222
|
+
if (shard && missing.length === 0)
|
|
223
|
+
reusedMonths += 1;
|
|
224
|
+
let fills = shard ? shard.fills : [];
|
|
225
|
+
let queried = existingQueried;
|
|
226
|
+
let changed = false;
|
|
227
|
+
for (const span of missing) {
|
|
228
|
+
const incoming = await doFetch(new Date(span.gte).toISOString(), new Date(span.lte).toISOString());
|
|
229
|
+
queriedFills += incoming.length;
|
|
230
|
+
fetchedSpans += 1;
|
|
231
|
+
fills = mergeFills(fills, incoming);
|
|
232
|
+
queried = addCoverage(queried, span, nowMs);
|
|
233
|
+
changed = true;
|
|
234
|
+
}
|
|
235
|
+
for (const f of fills) {
|
|
236
|
+
const t = Date.parse(f.time);
|
|
237
|
+
if (Number.isFinite(t) && t >= gteMs && t <= lteMs)
|
|
238
|
+
collected.set(fillKey(f), f);
|
|
239
|
+
}
|
|
240
|
+
if (changed) {
|
|
241
|
+
writeJsonAtomic(shardFile, {
|
|
242
|
+
meta: { accountId, fetchedAt: new Date(nowMs).toISOString(), queriedRanges: queried },
|
|
243
|
+
fills,
|
|
244
|
+
});
|
|
245
|
+
}
|
|
246
|
+
}
|
|
247
|
+
if (!options.quiet && fetchedSpans > 0) {
|
|
248
|
+
const reuseNote = reusedMonths > 0 ? `; ${reusedMonths} month(s) reused from cache` : '';
|
|
249
|
+
console.log(` [cache] queried ${fetchedSpans} fill range(s) (${queriedFills} fill(s))${reuseNote}`);
|
|
250
|
+
}
|
|
251
|
+
return [...collected.values()].sort(compareFills);
|
|
252
|
+
}
|
|
253
|
+
export { fetchFillsCached, shardKeyForTimestamp, shardBoundsForKey, shardKeysForRange, basePathFor, shardPathFor, normalizeQueried, addCoverage, trustedSegments, subtractRanges, mergeFills, fillKey, TAIL_SETTLE_LAG_MS, MAX_COVERAGE_SPANS, };
|
|
254
|
+
//# sourceMappingURL=fills_cache.js.map
|
|
@@ -60,10 +60,11 @@ const ASSETS = {
|
|
|
60
60
|
'1.3.6620': { symbol: 'XBTSX.A', precision: 6 },
|
|
61
61
|
'1.3.6627': { symbol: 'XBTSX.LINK', precision: 6 },
|
|
62
62
|
};
|
|
63
|
-
/** Precisions learned on-chain this run (populated by resolveAssetPrecisions). */
|
|
63
|
+
/** Precisions/symbols learned on-chain this run (populated by resolveAssetPrecisions). */
|
|
64
64
|
const resolvedPrecisions = {};
|
|
65
|
+
const resolvedSymbols = {};
|
|
65
66
|
function assetSymbol(id) {
|
|
66
|
-
return ASSETS[id]?.symbol ?? id;
|
|
67
|
+
return ASSETS[id]?.symbol ?? resolvedSymbols[id] ?? id;
|
|
67
68
|
}
|
|
68
69
|
function assetPrec(id) {
|
|
69
70
|
return ASSETS[id]?.precision ?? resolvedPrecisions[id];
|
|
@@ -98,6 +99,8 @@ async function resolveAssetPrecisions(fills) {
|
|
|
98
99
|
for (const asset of assets) {
|
|
99
100
|
if (asset?.id && asset.precision != null) {
|
|
100
101
|
resolvedPrecisions[asset.id] = asset.precision;
|
|
102
|
+
if (asset.symbol)
|
|
103
|
+
resolvedSymbols[asset.id] = String(asset.symbol);
|
|
101
104
|
console.log(` ${asset.id} → ${asset.symbol || '?'} (precision ${asset.precision})`);
|
|
102
105
|
}
|
|
103
106
|
}
|
|
@@ -0,0 +1,39 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* PROFESSIONAL PnL REPORT (HTML)
|
|
3
|
+
*
|
|
4
|
+
* Renders the output of analysis/trade_profitability.ts (PairAnalysis +
|
|
5
|
+
* realized lots + performance metrics) into a single self-contained HTML
|
|
6
|
+
* report: no sibling assets, no CDN, no network — it opens from a file://
|
|
7
|
+
* link on any machine.
|
|
8
|
+
*
|
|
9
|
+
* Centralises the report so every consumer (the `dexbot pnl` command and
|
|
10
|
+
* direct `node dist/analysis/trade_profitability.js --html` runs) emits the
|
|
11
|
+
* exact same layout. The type-only import from trade_profitability is erased
|
|
12
|
+
* at compile time, so there is no runtime import cycle.
|
|
13
|
+
*/
|
|
14
|
+
import type { PairAnalysis, TradingMetrics } from './trade_profitability.js';
|
|
15
|
+
interface PnlReportPair {
|
|
16
|
+
pair: PairAnalysis;
|
|
17
|
+
metrics: TradingMetrics;
|
|
18
|
+
}
|
|
19
|
+
interface PnlReportInput {
|
|
20
|
+
/** The reference the user typed (bot name, account name or 1.2.x id). */
|
|
21
|
+
accountRef: string;
|
|
22
|
+
/** Resolved chain account id (1.2.x). */
|
|
23
|
+
accountId: string;
|
|
24
|
+
/** Local bot profile name, when the reference resolved to one. */
|
|
25
|
+
botName?: string | null;
|
|
26
|
+
start: string;
|
|
27
|
+
end: string;
|
|
28
|
+
matchMode: string;
|
|
29
|
+
pairFilter?: string | null;
|
|
30
|
+
assetFilter?: string | null;
|
|
31
|
+
generatedAt?: string;
|
|
32
|
+
pairs: PnlReportPair[];
|
|
33
|
+
}
|
|
34
|
+
declare function renderPnlReportHtml(input: PnlReportInput): string;
|
|
35
|
+
/** Render + atomically write the report; returns the resolved file path. */
|
|
36
|
+
declare function writePnlReport(input: PnlReportInput, outputPath: string): string;
|
|
37
|
+
export { renderPnlReportHtml, writePnlReport };
|
|
38
|
+
export type { PnlReportInput, PnlReportPair };
|
|
39
|
+
//# sourceMappingURL=pnl_report.d.ts.map
|