dexbot 1.3.3 → 1.4.1

package/dist/analysis/trade_profitability.js

@@ -1,1247 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyzePair = analyzePair;
-exports.classifyFills = classifyFills;
-exports.computeMetrics = computeMetrics;
-const node_fs_1 = __importDefault(require("node:fs"));
-const kibana_client_1 = __importDefault(require("../market_adapter/core/kibana_client"));
-const constants_1 = __importDefault(require("../modules/constants"));
-const { kibanaSearch, DEFAULT_CONFIG: BASE_CONFIG } = kibana_client_1.default;
-/**
- * TRADE PROFITABILITY ANALYZER
- *
- * Fetches fill_order operations for a BitShares account from Kibana
- * within a specified time range, then analyzes profitability using
- * FIFO or sequential (LIFO) inventory tracking per asset pair.
- *
- * Usage:
- *   tsx analysis/trade_profitability.ts 1.2.3 --start 2025-01-01 --end 2025-06-01
- *   tsx analysis/trade_profitability.ts 1.2.3 --hours 720
- *   tsx analysis/trade_profitability.ts 1.2.3 --start 2025-01-01T00:00:00Z --end 2025-06-01T00:00:00Z
- *   tsx analysis/trade_profitability.ts 1.2.3 --hours 168 --asset 1.3.113
- *   tsx analysis/trade_profitability.ts 1.2.3 --hours 168 --csv trades.csv
- *   tsx analysis/trade_profitability.ts 1.2.3 --hours 168 --json results.json
- *   tsx analysis/trade_profitability.ts "account-name" --lookup
- *   tsx analysis/trade_profitability.ts 1.2.3 --hours 168 --trades
- *   tsx analysis/trade_profitability.ts 1.2.3 --hours 168 --match-mode fifo
- */
-// ─── Constants ────────────────────────────────────────────────────────────────
-const OP_FILL_ORDER = 4;
-const BTS_ID = '1.3.0';
-let BLOCKCHAIN_FEE_PER_FILL = 0.09652; // BTS — flat blockchain operation fee (not market fee); override with --fee-per-order
-const ASSETS = {
-    '1.3.0': { symbol: 'BTS', precision: 5 },
-    '1.3.118': { symbol: 'GBP', precision: 4 },
-    '1.3.119': { symbol: 'JPY', precision: 2 },
-    '1.3.120': { symbol: 'EUR', precision: 4 },
-    '1.3.1325': { symbol: 'RUBLE', precision: 5 },
-    '1.3.2512': { symbol: 'EVRAZ', precision: 4 },
-    '1.3.3291': { symbol: 'TWENTIX', precision: 5 },
-    '1.3.4099': { symbol: 'XBTSX.STH', precision: 6 },
-    '1.3.4156': { symbol: 'XBTSX.DOGE', precision: 5 },
-    '1.3.4157': { symbol: 'XBTSX.BTC', precision: 8 },
-    '1.3.4159': { symbol: 'XBTSX.LTC', precision: 8 },
-    '1.3.4176': { symbol: 'XBTSX.DASH', precision: 8 },
-    '1.3.4274': { symbol: 'XBTSX.BCH', precision: 8 },
-    '1.3.4760': { symbol: 'XBTSX.ETH', precision: 7 },
-    '1.3.5537': { symbol: 'IOB.XRP', precision: 4 },
-    '1.3.5541': { symbol: 'XBTSX.BNB', precision: 7 },
-    '1.3.5589': { symbol: 'XBTSX.USDT', precision: 6 },
-    '1.3.5641': { symbol: 'HONEST.CNY', precision: 4 },
-    '1.3.5649': { symbol: 'HONEST.USD', precision: 4 },
-    '1.3.5650': { symbol: 'HONEST.BTC', precision: 8 },
-    '1.3.5659': { symbol: 'HONEST.ETH', precision: 6 },
-    '1.3.5870': { symbol: 'XBTSX.FIL', precision: 6 },
-    '1.3.5887': { symbol: 'XBTSX.RUB', precision: 4 },
-    '1.3.5902': { symbol: 'XBTSX.USDC', precision: 6 },
-    '1.3.6013': { symbol: 'XBTSX.HIVE', precision: 6 },
-    '1.3.6124': { symbol: 'XBTSX.AVAX', precision: 6 },
-    '1.3.6139': { symbol: 'XBTSX.XAUT', precision: 6 },
-    '1.3.6166': { symbol: 'XBTSX.MATIC', precision: 5 },
-    '1.3.6241': { symbol: 'XBTSX.ETC', precision: 7 },
-    '1.3.6268': { symbol: 'BTWTY.EOS', precision: 4 },
-    '1.3.6301': { symbol: 'HONEST.MONEY', precision: 8 },
-    '1.3.6304': { symbol: 'HONEST.ADA', precision: 8 },
-    '1.3.6305': { symbol: 'HONEST.DOT', precision: 8 },
-    '1.3.6309': { symbol: 'HONEST.ATOM', precision: 8 },
-    '1.3.6311': { symbol: 'HONEST.ALGO', precision: 8 },
-    '1.3.6312': { symbol: 'HONEST.FIL', precision: 8 },
-    '1.3.6313': { symbol: 'HONEST.EOS', precision: 8 },
-    '1.3.6315': { symbol: 'HONEST.EUR', precision: 4 },
-    '1.3.6316': { symbol: 'HONEST.GBP', precision: 4 },
-    '1.3.6317': { symbol: 'HONEST.JPY', precision: 4 },
-    '1.3.6444': { symbol: 'IOB.XLM', precision: 4 },
-    '1.3.6573': { symbol: 'XBTSX.DAI', precision: 6 },
-    '1.3.6620': { symbol: 'XBTSX.A', precision: 6 },
-    '1.3.6627': { symbol: 'XBTSX.LINK', precision: 6 },
-};
-const resolvedPrecisions = {};
-function assetSymbol(id) {
-    return ASSETS[id]?.symbol ?? id;
-}
-function assetPrec(id) {
-    return ASSETS[id]?.precision ?? resolvedPrecisions[id];
-}
-function getPrec(id) {
-    return assetPrec(id);
-}
-function toReal(amount, assetId) {
-    const p = getPrec(assetId);
-    if (p === undefined)
-        return NaN;
-    return amount / Math.pow(10, p);
-}
-// ─── CLI ──────────────────────────────────────────────────────────────────────
-function printHelp() {
-    console.log(`\
-Usage: tsx analysis/trade_profitability.ts <accountId> [options]
-
-Analyzes filled orders for a BitShares account, computing realized PnL
-via FIFO or sequential (LIFO) inventory tracking.
-
-Arguments:
-  accountId              BitShares account ID (1.2.x) or name (with --lookup)
-
-Options:
-  --start <iso>          Start time (ISO 8601, e.g. 2025-01-01 or 2025-01-01T00:00:00Z)
-  --end <iso>            End time (ISO 8601)
-  --hours <n>            Lookback hours from now (alternative to --start/--end)
-  --asset <assetId>      Filter to one base asset (e.g. 1.3.113 for bitUSD)
-  --lookup               Resolve account name to ID via BitShares node
-  --node <url>           BitShares node URL (default: first healthy from built-in pool)
-  --csv <file>           Export trade list as CSV
-  --json <file>          Export full analysis as JSON
-  --trades               Show per-order PnL detail (hidden by default)
-  --match-mode <mode>    Matching mode: sequential (default, LIFO) or fifo
-  --fee-per-order <bts>  Blockchain fee per limit_order_create op in BTS (default: 0.09652)
-  --verbose              Print extra debug info
-  --help, -h             Show this help
-
-Examples:
-  tsx analysis/trade_profitability.ts 1.2.123456 --hours 720
-  tsx analysis/trade_profitability.ts 1.2.123456 --start 2025-01-01 --end 2025-06-01
-  tsx analysis/trade_profitability.ts "my-bot-account" --lookup --hours 168
-  tsx analysis/trade_profitability.ts 1.2.123456 --hours 720 --asset 1.3.113 --csv trades.csv
-  tsx analysis/trade_profitability.ts 1.2.123456 --hours 720 --match-mode sequential`);
-}
-function parseArgs() {
-    const args = process.argv.slice(2);
-    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
-        printHelp();
-        process.exit(0);
-    }
-    const opts = {
-        accountId: args[0],
-        hours: null,
-        start: null,
-        end: null,
-        asset: null,
-        lookup: false,
-        node: constants_1.default.NODE_MANAGEMENT.DEFAULT_NODES[0],
-        csv: null,
-        json: null,
-        matchMode: 'sequential',
-        showPnlDetail: false,
-        verbose: false,
-        feePerOrder: BLOCKCHAIN_FEE_PER_FILL,
-    };
-    for (let i = 1; i < args.length; i++) {
-        switch (args[i]) {
-            case '--hours':
-                opts.hours = parseInt(args[++i], 10);
-                break;
-            case '--start':
-                opts.start = args[++i];
-                break;
-            case '--end':
-                opts.end = args[++i];
-                break;
-            case '--asset':
-                opts.asset = args[++i];
-                break;
-            case '--lookup':
-                opts.lookup = true;
-                break;
-            case '--node':
-                opts.node = args[++i];
-                break;
-            case '--csv':
-                opts.csv = args[++i];
-                break;
-            case '--json':
-                opts.json = args[++i];
-                break;
-            case '--trades':
-                opts.showPnlDetail = true;
-                break;
-            case '--fee-per-order':
-                opts.feePerOrder = parseFloat(args[++i]);
-                break;
-            case '--match-mode': {
-                const m = args[++i];
-                if (m !== 'sequential' && m !== 'fifo') {
-                    console.error(`Invalid --match-mode: ${m} (expected: sequential | fifo)`);
-                    process.exit(1);
-                }
-                opts.matchMode = m;
-                break;
-            }
-            case '--verbose':
-                opts.verbose = true;
-                break;
-            default:
-                console.error(`Unknown option: ${args[i]}`);
-                process.exit(1);
-        }
-    }
-    if (!opts.hours && !opts.start) {
-        opts.hours = 168; // default: 7 days
-    }
-    return opts;
-}
-// ─── Account name resolution ─────────────────────────────────────────────────
-async function resolveAccountId(name, nodeUrl) {
-    const mod = await import('../modules/bitshares-native/index.js');
-    const { createReadOnlyClient } = mod.default;
-    const client = createReadOnlyClient({ nodes: [nodeUrl] });
-    // Suppress transport INFO logs during ephemeral connection:
-    // bitshares-native transport logger (new Logger('Transport')) writes
-    // "[timestamp] [INFO] [Transport] ..." — silence by raising log level.
-    const prevLevel = process.env.LOG_LEVEL;
-    process.env.LOG_LEVEL = 'warn';
-    try {
-        await client.connect();
-        const accounts = await client.db('lookup_account_names', [[name]]);
-        if (Array.isArray(accounts) && accounts[0]?.id) {
-            return accounts[0].id;
-        }
-        return null;
-    }
-    catch (e) {
-        console.warn(`  [warn] Account resolution failed: ${e.message}`);
-        return null;
-    }
-    finally {
-        try {
-            client.disconnect();
-        }
-        catch (_) { }
-        process.env.LOG_LEVEL = prevLevel;
-    }
-}
-// ─── On-chain asset precision resolution ────────────────────────────────────
-/**
- * Collects all unique non-BTS asset IDs from fills, resolves unknown
- * precisions from the blockchain, and populates the runtime cache.
- */
-async function resolveAssetPrecisions(fills, nodeUrl) {
-    const unknownIds = new Set();
-    for (const f of fills) {
-        for (const id of [f.pays.asset_id, f.receives.asset_id, f.fee.asset_id]) {
-            if (id !== BTS_ID && !(id in ASSETS) && !(id in resolvedPrecisions)) {
-                unknownIds.add(id);
-            }
-        }
-    }
-    if (unknownIds.size === 0 || !nodeUrl)
-        return;
-    const ids = [...unknownIds];
-    console.log(`  Resolving ${ids.length} unknown asset(s) from blockchain...`);
-    const mod = await import('../modules/bitshares-native/index.js');
-    const { createReadOnlyClient } = mod.default;
-    const client = createReadOnlyClient({ nodes: [nodeUrl] });
-    try {
-        await client.connect();
-        const assets = await client.db('get_assets', [ids]);
-        if (Array.isArray(assets)) {
-            for (const asset of assets) {
-                if (asset?.id && asset.precision != null) {
-                    resolvedPrecisions[asset.id] = asset.precision;
-                    console.log(`    ${asset.id} → ${asset.symbol || '?'} (precision ${asset.precision})`);
-                }
-            }
-        }
-        const missing = ids.filter(id => !(id in resolvedPrecisions));
-        if (missing.length > 0) {
-            console.warn(`  [warn] ${missing.length} asset(s) not found on chain: ${missing.join(', ')}. Fills referencing them will be skipped.`);
-        }
-    }
-    catch (e) {
-        console.warn(`  [warn] Asset resolution failed: ${e.message}. Fills with unknown assets will be skipped.`);
-    }
-    finally {
-        try {
-            client.disconnect();
-        }
-        catch (_) { }
-    }
-}
-// ─── Kibana Query ────────────────────────────────────────────────────────────
-function buildFillQuery(accountId, gte, lte, size) {
-    return {
-        size,
-        track_total_hits: false,
-        _source: [
-            'block_data.block_time',
-            'block_data.block_num',
-            'operation_id_num',
-            'operation_history.op_object.pays',
-            'operation_history.op_object.receives',
-            'operation_history.op_object.fee',
-            'operation_history.op_object.order_id',
-            'operation_history.op_object.account_id',
-            'operation_history.op_object.is_maker',
-        ],
-        query: {
-            bool: {
-                filter: [
-                    { term: { operation_type: OP_FILL_ORDER } },
-                    { term: { 'operation_history.op_object.account_id.keyword': accountId } },
-                    { range: { 'block_data.block_time': { gte, lte } } },
-                ],
-            },
-        },
-        sort: [
-            { 'block_data.block_time': { order: 'asc' } },
-            { operation_id_num: { order: 'asc' } },
-        ],
-    };
-}
-async function fetchAllFills(config, accountId, gte, lte) {
-    const pageSize = 10000;
-    const fills = [];
-    let searchAfter = null;
-    const cfg = { ...BASE_CONFIG, timeout: 60000, ...config };
-    while (true) {
-        const query = buildFillQuery(accountId, gte, lte, pageSize);
-        if (searchAfter)
-            query.search_after = searchAfter;
-        const result = await kibanaSearch(cfg, query);
-        const hits = result?.hits?.hits ?? [];
-        if (!hits.length)
-            break;
-        for (const hit of hits) {
-            const src = hit?._source;
-            const op = src?.operation_history?.op_object;
-            if (!op || !op.pays || !op.receives)
-                continue;
-            fills.push({
-                time: src.block_data?.block_time ?? '',
-                blockNum: src.block_data?.block_num ?? 0,
-                opNum: Number(src.operation_id_num ?? 0),
-                orderId: op.order_id ?? '',
-                accountId: op.account_id ?? '',
-                pays: { amount: Number(op.pays.amount ?? 0), asset_id: op.pays.asset_id ?? '' },
-                receives: { amount: Number(op.receives.amount ?? 0), asset_id: op.receives.asset_id ?? '' },
-                fee: { amount: Number(op.fee?.amount ?? 0), asset_id: op.fee?.asset_id ?? '' },
-                isMaker: op.is_maker ?? false,
-                sort: hit.sort,
-            });
-        }
-        if (hits.length < pageSize)
-            break;
-        searchAfter = hits[hits.length - 1].sort;
-        if (!Array.isArray(searchAfter))
-            break;
-    }
-    return fills;
-}
-// ─── Fill Classification ─────────────────────────────────────────────────────
-function classifyFills(fills, filterAsset) {
-    const trades = [];
-    const pairs = new Set();
-    let skipped = 0;
-    for (const f of fills) {
-        const pAsset = f.pays.asset_id;
-        const rAsset = f.receives.asset_id;
-        let direction;
-        let baseAsset;
-        let quoteAsset;
-        let baseAmount;
-        let quoteAmount;
-        let price;
-        let marketFeeReal;
-        let marketFeeAsset;
-        const feePrec = getPrec(f.fee.asset_id);
-        if (feePrec === undefined || isNaN(f.fee.amount)) {
-            skipped++;
-            continue;
-        }
-        const feeReal = f.fee.amount / Math.pow(10, feePrec);
-        if (pAsset === BTS_ID && rAsset !== BTS_ID) {
-            direction = 'buy';
-            baseAsset = rAsset;
-            quoteAsset = BTS_ID;
-            baseAmount = toReal(f.receives.amount, rAsset);
-            quoteAmount = toReal(f.pays.amount, BTS_ID);
-            if (isNaN(baseAmount) || isNaN(quoteAmount)) {
-                skipped++;
-                continue;
-            }
-            price = quoteAmount / baseAmount;
-            marketFeeReal = feeReal;
-            marketFeeAsset = f.fee.asset_id;
-        }
-        else if (rAsset === BTS_ID && pAsset !== BTS_ID) {
-            direction = 'sell';
-            baseAsset = pAsset;
-            quoteAsset = BTS_ID;
-            baseAmount = toReal(f.pays.amount, pAsset);
-            quoteAmount = toReal(f.receives.amount, BTS_ID);
-            if (isNaN(baseAmount) || isNaN(quoteAmount)) {
-                skipped++;
-                continue;
-            }
-            price = quoteAmount / baseAmount;
-            marketFeeReal = feeReal;
-            marketFeeAsset = f.fee.asset_id;
-        }
-        else {
-            // Non-BTS cross-pair: use consistent ordering (lower asset ID = base)
-            const baseForCheck = pAsset < rAsset ? pAsset : rAsset;
-            const quoteForCheck = pAsset < rAsset ? rAsset : pAsset;
-            // Skip if either asset precision is unknown
-            if (getPrec(baseForCheck) === undefined || getPrec(quoteForCheck) === undefined) {
-                skipped++;
-                continue;
-            }
-            const isSell = pAsset < rAsset;
-            direction = isSell ? 'sell' : 'buy';
-            baseAsset = isSell ? pAsset : rAsset;
-            quoteAsset = isSell ? rAsset : pAsset;
-            baseAmount = toReal(isSell ? f.pays.amount : f.receives.amount, baseAsset);
-            quoteAmount = toReal(isSell ? f.receives.amount : f.pays.amount, quoteAsset);
-            if (isNaN(baseAmount) || isNaN(quoteAmount)) {
-                skipped++;
-                continue;
-            }
-            price = quoteAmount / baseAmount;
-            marketFeeReal = feeReal;
-            marketFeeAsset = f.fee.asset_id;
-        }
-        if (filterAsset && baseAsset !== filterAsset)
-            continue;
-        // Validate market fee asset: fee is always deducted from receives
-        // (base for buys, quote for sells). Warn if unexpected.
-        if (marketFeeReal > 0 && marketFeeAsset !== '' && marketFeeAsset !== rAsset) {
-            console.warn(`  [warn] Fill ${f.orderId}: fee asset ${marketFeeAsset} ≠ receives asset ${rAsset}. Market fee PnL may be incorrect.`);
-        }
-        const pairKey = `${baseAsset}:${quoteAsset}`;
-        pairs.add(pairKey);
-        trades.push({
-            time: f.time,
-            orderId: f.orderId,
-            direction,
-            baseAsset,
-            quoteAsset,
-            baseAmount,
-            quoteAmount,
-            price,
-            isMaker: f.isMaker,
-            sequence: f.blockNum * 1e6 + f.opNum,
-            marketFeeReal,
-            marketFeeAsset,
-        });
-    }
-    if (skipped > 0) {
-        console.warn(`  [warn] ${skipped} fill(s) skipped due to unknown asset precision.`);
-    }
-    return { trades, pairs };
-}
-// ─── PnL Calculation (FIFO / Sequential) ─────────────────────────────────────
-function analyzePair(trades, matchMode = 'sequential') {
-    const buys = trades.filter(t => t.direction === 'buy').sort((a, b) => a.sequence - b.sequence);
-    const sells = trades.filter(t => t.direction === 'sell').sort((a, b) => a.sequence - b.sequence);
-    const totalBuyBase = buys.reduce((s, t) => s + t.baseAmount, 0);
-    const totalSellBase = sells.reduce((s, t) => s + t.baseAmount, 0);
-    const totalBuyQuote = buys.reduce((s, t) => s + t.quoteAmount, 0);
-    const totalSellQuote = sells.reduce((s, t) => s + t.quoteAmount, 0);
-    // Merge all trades chronologically.
-    // FIFO: buys add to queue, sells consume oldest lots (queue front).
-    // Sequential: buys add to queue, sells consume newest lots (queue back / LIFO).
-    const all = [...trades].sort((a, b) => a.sequence - b.sequence);
-    const inventory = [];
-    const realizedPnls = [];
-    let unmatchedSellBase = 0;
-    for (const trade of all) {
-        const grossPrice = trade.price;
-        if (trade.direction === 'buy') {
-            // Enter lot with net amount (gross receives minus market fee on receives)
-            const lotAmount = trade.baseAmount - trade.marketFeeReal;
-            if (lotAmount < 1e-12)
-                continue;
-            const lotEffPrice = trade.quoteAmount / lotAmount;
-            inventory.push({
-                amount: lotAmount,
-                grossPrice: grossPrice,
-                effPrice: lotEffPrice,
-                time: trade.time,
-                entryOrderId: trade.orderId,
-                entryIsMaker: trade.isMaker,
-            });
-        }
-        else {
-            let remaining = trade.baseAmount;
-            while (remaining > 0.00000001 && inventory.length > 0) {
-                const lotIndex = matchMode === 'sequential' ? inventory.length - 1 : 0;
-                const lot = inventory[lotIndex];
-                const matched = Math.min(remaining, lot.amount);
-                // Gross PnL using gross prices (before market fee deduction)
-                const grossPnl = (grossPrice - lot.grossPrice) * matched;
-                const grossPnlPct = lot.grossPrice > 0 ? ((grossPrice - lot.grossPrice) / lot.grossPrice) * 100 : 0;
-                realizedPnls.push({
-                    sellPrice: grossPrice,
-                    buyPrice: lot.grossPrice,
-                    amount: matched,
-                    pnl: grossPnl,
-                    pnlPct: grossPnlPct,
-                    effPrice: lot.effPrice,
-                    marketFeeEntry: 0,
-                    marketFeeExit: 0,
-                    feeBts: 0,
-                    pnlNet: grossPnl,
-                    pnlNetPct: grossPnlPct,
-                    entryTime: lot.time,
-                    exitTime: trade.time,
-                    entryOrderId: lot.entryOrderId,
-                    exitOrderId: trade.orderId,
-                    entryIsMaker: lot.entryIsMaker,
-                    exitIsMaker: trade.isMaker,
-                });
-                lot.amount -= matched;
-                remaining -= matched;
-                if (lot.amount < 0.00000001) {
-                    if (matchMode === 'sequential') {
-                        inventory.pop();
-                    }
-                    else {
-                        inventory.shift();
-                    }
-                }
-            }
-            if (remaining > 0.00000001) {
-                unmatchedSellBase += remaining;
-            }
-        }
-    }
-    // ─── Market fee allocation (aggregated per order) ──────────────────────
-    // A limit order may be filled across multiple fill_order_operations with
-    // the same orderId.  Aggregate all fills' market fees per order, then
-    // allocate pro-rata using the fill's net acquired amount as denominator.
-    // (Market fee is paid on acquisition; the portion tied to unsold inventory
-    //  is not yet realised.)
-    const entryOrderFees = new Map();
-    const exitOrderFees = new Map();
-    for (const t of buys) {
-        const e = entryOrderFees.get(t.orderId) || { feeInQuote: 0, totalAcquired: 0 };
-        if (t.marketFeeReal > 0) {
-            // Buy-side fee is in base → convert to quote using effective price
-            const netBase = t.baseAmount - t.marketFeeReal;
-            e.feeInQuote += netBase > 0 ? t.marketFeeReal * (t.quoteAmount / netBase) : 0;
-        }
-        e.totalAcquired += t.baseAmount - t.marketFeeReal;
-        entryOrderFees.set(t.orderId, e);
-    }
-    for (const t of sells) {
-        const e = exitOrderFees.get(t.orderId) || { feeInQuote: 0, totalDisposed: 0 };
-        if (t.marketFeeReal > 0)
-            e.feeInQuote += t.marketFeeReal; // Sell-side fee is already in quote
-        e.totalDisposed += t.baseAmount;
-        exitOrderFees.set(t.orderId, e);
-    }
-    for (const r of realizedPnls) {
-        const eObj = entryOrderFees.get(r.entryOrderId);
-        if (eObj && eObj.totalAcquired > 0)
-            r.marketFeeEntry = eObj.feeInQuote * (r.amount / eObj.totalAcquired);
-        const xObj = exitOrderFees.get(r.exitOrderId);
-        if (xObj && xObj.totalDisposed > 0)
-            r.marketFeeExit = xObj.feeInQuote * (r.amount / xObj.totalDisposed);
-        r.pnlNet = r.pnl - r.marketFeeEntry - r.marketFeeExit;
-        r.pnlNetPct = r.buyPrice > 0 ? (r.pnlNet / (r.buyPrice * r.amount)) * 100 : 0;
-    }
-    // ─── Blockchain fee allocation ─────────────────────────────────────────
-    const buyOrderIds = new Set(buys.map(t => t.orderId));
-    const sellOrderIds = new Set(sells.map(t => t.orderId));
-    const entryTotalMatched = new Map();
-    const exitTotalMatched = new Map();
-    for (const r of realizedPnls) {
-        entryTotalMatched.set(r.entryOrderId, (entryTotalMatched.get(r.entryOrderId) || 0) + r.amount);
-        exitTotalMatched.set(r.exitOrderId, (exitTotalMatched.get(r.exitOrderId) || 0) + r.amount);
-    }
-    const totalBlockchainFees = (buyOrderIds.size + sellOrderIds.size) * BLOCKCHAIN_FEE_PER_FILL;
-    for (const r of realizedPnls) {
-        const eTotal = entryTotalMatched.get(r.entryOrderId) || 1;
-        const xTotal = exitTotalMatched.get(r.exitOrderId) || 1;
-        r.feeBts = BLOCKCHAIN_FEE_PER_FILL * (r.amount / eTotal) + BLOCKCHAIN_FEE_PER_FILL * (r.amount / xTotal);
-        r.pnlNet -= r.feeBts;
-        const costBasis = r.effPrice * r.amount;
-        r.pnlNetPct = costBasis > 0 ? (r.pnlNet / costBasis) * 100 : 0;
-    }
-    const totalBuyBaseNet = buys.reduce((s, t) => s + t.baseAmount - t.marketFeeReal, 0);
-    const totalRealizedPnl = realizedPnls.reduce((s, r) => s + r.pnl, 0);
-    const totalMarketFees = realizedPnls.reduce((s, r) => s + r.marketFeeEntry + r.marketFeeExit, 0);
-    const totalRealizedPnlNet = realizedPnls.reduce((s, r) => s + r.pnlNet, 0);
-    const netPosition = totalBuyBaseNet - totalSellBase;
-    const baseAsset = trades[0]?.baseAsset ?? '';
-    const quoteAsset = trades[0]?.quoteAsset ?? '';
-    return {
-        baseAsset,
-        quoteAsset,
-        buys,
-        sells,
-        realizedPnls,
-        totalBuyBase,
-        totalSellBase,
-        totalBuyQuote,
-        totalSellQuote,
-        unmatchedSellBase,
-        totalRealizedPnl,
-        totalMarketFees,
-        totalBlockchainFees,
-        totalRealizedPnlNet,
-        netPosition,
-    };
-}
-// ─── Output Helpers ──────────────────────────────────────────────────────────
-function fmt(n, decimals = 4) {
-    if (!Number.isFinite(n))
-        return 'NaN';
-    return n.toLocaleString('en-US', { minimumFractionDigits: decimals, maximumFractionDigits: decimals });
-}
-function fmtPct(n) {
-    if (!Number.isFinite(n))
-        return 'NaN%';
-    return (n >= 0 ? '+' : '') + n.toFixed(2) + '%';
-}
-function fmtAsset(id) {
-    return assetSymbol(id);
-}
-function printSummary(pairs, accountId, start, end, matchMode = 'sequential') {
-    console.log('');
-    for (const pair of pairs) {
-        const pairLabel = `${fmtAsset(pair.baseAsset)}/${fmtAsset(pair.quoteAsset)}`;
-        const totalBought = pair.totalBuyBase;
-        const totalSold = pair.totalSellBase;
-        const avgBuy = pair.totalBuyBase > 0 ? pair.totalBuyQuote / pair.totalBuyBase : 0;
-        const avgSell = pair.totalSellBase > 0 ? pair.totalSellQuote / pair.totalSellBase : 0;
-        console.log(` ── ${pairLabel}`);
-        console.log(`    Buys:        ${fmt(totalBought, 4)} @ ${fmt(avgBuy, 6)} = ${fmt(pair.totalBuyQuote, 4)} ${fmtAsset(pair.quoteAsset)}`);
-        console.log(`    Sells:       ${fmt(totalSold, 4)} @ ${fmt(avgSell, 6)} = ${fmt(pair.totalSellQuote, 4)} ${fmtAsset(pair.quoteAsset)}`);
-        console.log(`    Net traded:  ${fmt(pair.netPosition, 4)} ${fmtAsset(pair.baseAsset)} (window flow)`);
-        console.log(`    Trades:      ${pair.realizedPnls.length} matched lots, ${pair.buys.length} buys, ${pair.sells.length} sells`);
-        if (pair.unmatchedSellBase > 0.0001) {
-            console.log(`    Unmatched:   ${fmt(pair.unmatchedSellBase, 4)} ${fmtAsset(pair.baseAsset)} (sold without prior buy in window — expected if inventory predates window)`);
-        }
-        console.log(`    Gross PnL:    ${fmtAsset(pair.quoteAsset)} ${fmt(pair.totalRealizedPnl, 4)}`);
-        const mktFee = pair.totalMarketFees;
-        const blkFee = pair.totalBlockchainFees;
-        if (mktFee > 0.0001) {
-            console.log(`    Market fees:  ${fmtAsset(pair.quoteAsset)} ${fmt(-mktFee, 4)}`);
-        }
-        if (blkFee > 0.0001) {
-            console.log(`    Blockchain:   BTS ${fmt(-blkFee, 4)}`);
-        }
-        console.log(`    Net PnL:      ${fmtAsset(pair.quoteAsset)} ${fmt(pair.totalRealizedPnlNet, 4)}`);
-        if (pair.quoteAsset !== BTS_ID) {
-            console.log(`    ⚠ Non-BTS quote — PnL is in ${fmtAsset(pair.quoteAsset)}, not BTS`);
-        }
-        console.log('');
-    }
-    // Grand totals grouped by quote asset
-    const quoteGroups = new Map();
-    for (const p of pairs) {
-        const q = p.quoteAsset;
-        if (!quoteGroups.has(q))
-            quoteGroups.set(q, []);
-        quoteGroups.get(q).push(p);
-    }
-    if (pairs.length > 1 && quoteGroups.size > 0) {
-        for (const [quoteAsset, group] of quoteGroups) {
-            const groupPnl = group.reduce((s, p) => s + p.totalRealizedPnl, 0);
-            const groupMktFees = group.reduce((s, p) => s + p.totalMarketFees, 0);
-            const groupBlkFees = group.reduce((s, p) => s + p.totalBlockchainFees, 0);
-            const groupNet = group.reduce((s, p) => s + p.totalRealizedPnlNet, 0);
-            const groupVol = group.reduce((s, p) => s + p.totalBuyQuote + p.totalSellQuote, 0);
-            const qSymbol = fmtAsset(quoteAsset);
-            console.log(` ── TOTAL (${qSymbol}) — ${group.length} pair(s)`);
-            console.log(`    Gross PnL:    ${fmtAsset(quoteAsset)} ${fmt(groupPnl, 4)}`);
-            if (groupMktFees > 0.0001) {
-                console.log(`    Market fees:  ${fmtAsset(quoteAsset)} ${fmt(-groupMktFees, 4)}`);
-            }
-            if (groupBlkFees > 0.0001) {
-                console.log(`    Blockchain:   BTS ${fmt(-groupBlkFees, 4)}`);
-            }
-            console.log(`    Net PnL:      ${fmtAsset(quoteAsset)} ${fmt(groupNet, 4)}`);
-            console.log(`    Volume:       ${fmt(groupVol, 4)} ${qSymbol}`);
-            console.log('');
-        }
-    }
-    console.log(`  Note: PnL uses gross prices. Net PnL deducts market fees (charged by`);
-    console.log(`        asset issuer on receives, both issuer and network portions) and`);
-    console.log(`        blockchain operation fees (BTS per limit_order_create). Market`);
-    console.log(`        fees are converted to quote asset. Buy lots are entered at net`);
-    console.log(`        receives (gross minus buy-side market fee) so inventory matching`);
-    console.log(`        reflects what the account actually held. If inventory predates the`);
-    console.log(`        window or crosses asset pairs, the matched lots may not reflect`);
-    console.log(`        true trade economics.`);
-    console.log('');
-}
-function printPnlDetail(pairs) {
-    for (const pair of pairs) {
-        if (pair.realizedPnls.length === 0)
-            continue;
-        const pairLabel = `${fmtAsset(pair.baseAsset)}/${fmtAsset(pair.quoteAsset)}`;
-        console.log('');
-        console.log(` ── ${pairLabel} — Realized PnL Detail`);
-        console.log('');
-        const hdr = ' #   Buy Price    EffBuy      Sell Price   Amount    PnL         PnL%      MktFee    OpFeeBTS  Net PnL     Net%     Legs  Entry Time              Exit Time';
-        console.log(hdr);
-        console.log(' ' + '─'.repeat(hdr.length - 1));
-        for (let i = 0; i < pair.realizedPnls.length; i++) {
-            const r = pair.realizedPnls[i];
-            const idx = String(i + 1).padStart(2);
-            const bp = fmt(r.buyPrice, 8).padStart(11);
-            const ep = fmt(r.effPrice, 8).padStart(11);
-            const sp = fmt(r.sellPrice, 8).padStart(11);
-            const amt = fmt(r.amount, 4).padStart(9);
-            const pnlStr = fmt(r.pnl, 6).padStart(9);
-            const pctStr = fmtPct(r.pnlPct).padStart(8);
-            const mktFeeStr = fmt(r.marketFeeEntry + r.marketFeeExit, 4).padStart(8);
-            const feeStr = fmt(r.feeBts, 4).padStart(8);
-            const netStr = fmt(r.pnlNet, 6).padStart(10);
-            const netPctStr = fmtPct(r.pnlNetPct).padStart(8);
-            const mk = (r.entryIsMaker ? 'M' : 'T') + '/' + (r.exitIsMaker ? 'M' : 'T') + ' ';
-            const et = (r.entryTime || '').slice(0, 22).padEnd(22);
-            const xt = (r.exitTime || '').slice(0, 22).padEnd(22);
-            console.log(` ${idx}  ${bp}  ${ep}  ${sp}  ${amt}  ${pnlStr}  ${pctStr}  ${mktFeeStr}  ${feeStr}  ${netStr}  ${netPctStr}  ${mk}  ${et}  ${xt}`);
-        }
-        console.log('');
-    }
-}
-function percentile(sorted, p) {
-    const n = sorted.length;
-    if (n === 0)
-        return 0;
-    if (n === 1)
-        return sorted[0];
-    const k = (p / 100) * (n - 1);
-    const f = Math.floor(k);
-    const c = Math.ceil(k);
-    if (f === c)
-        return sorted[f];
-    return sorted[f] * (c - k) + sorted[c] * (k - f);
-}
-function computeMetrics(pair) {
-    const pnls = pair.realizedPnls;
-    const total = pnls.length;
-    if (total === 0) {
-        return {
-            totalLots: 0, winRate: 0, profitFactor: 0,
-            avgWin: 0, avgLoss: 0, avgWinLossRatio: 0,
-            expectancyBts: 0, expectancyPct: 0, expectancyR: 0,
-            netExpectancyBts: 0,
-            dailyPnlRatio: 0, dailyDownsideRatio: 0,
-            maxConsecWins: 0, maxConsecLosses: 0,
-            avgHoldHours: 0, limitOrderRatio: 0,
-            bestTradePct: 0, worstTradePct: 0,
-            mddPct: 0,
-            mddHadStablePeak: false,
-            isOngoingRecovery: false,
-            currentDrawdownDays: 0,
-            medianPnlPct: 0, p25PnlPct: 0, p75PnlPct: 0,
-            feeDragPct: 0, maxRecoveryDays: 0,
-            medianR: 0, pctRGreater1: 0, pctRGreater2: 0, pctRLessNeg1: 0,
-            sellOrdersFilled: 0, fillsPerOrderMean: 0, fillsPerOrderMedian: 0,
-            fillsPerOrderMax: 0, oneShotOrderRatio: 0, fillsPerDay: 0, avgVolumePerDay: 0,
-        };
-    }
-    const wins = pnls.filter(r => r.pnl > 0);
-    const losses = pnls.filter(r => r.pnl < 0);
-    const winRate = wins.length / total;
-    const makerEntryCount = pnls.filter(r => r.entryIsMaker).length;
-    const makerExitCount = pnls.filter(r => r.exitIsMaker).length;
-    const totalMakerLegs = makerEntryCount + makerExitCount;
-    const grossProfit = wins.reduce((s, r) => s + r.pnl, 0);
-    const grossLoss = Math.abs(losses.reduce((s, r) => s + r.pnl, 0));
-    const profitFactor = grossLoss > 0 ? grossProfit / grossLoss : grossProfit > 0 ? Infinity : 0;
-    const totalFeeDrag = pair.totalMarketFees + pair.totalBlockchainFees;
-    const feeDragPct = grossProfit > 0 ? (totalFeeDrag / grossProfit) * 100 : 0;
-    const avgWin = wins.length > 0 ? grossProfit / wins.length : 0;
-    const avgLoss = losses.length > 0 ? losses.reduce((s, r) => s + r.pnl, 0) / losses.length : 0;
-    const avgWinPct = wins.length > 0 ? wins.reduce((s, r) => s + r.pnlPct, 0) / wins.length : 0;
-    const avgLossPct = losses.length > 0 ? losses.reduce((s, r) => s + r.pnlPct, 0) / losses.length : 0;
-    const avgWinLossRatio = avgLoss !== 0 ? avgWin / Math.abs(avgLoss) : avgWin > 0 ? Infinity : 0;
-    const expectancyBts = (winRate * avgWin) + ((1 - winRate) * avgLoss);
-    const expectancyPct = (winRate * avgWinPct) + ((1 - winRate) * avgLossPct);
-    const rMultiple = Math.abs(avgLoss);
-    const expectancyR = rMultiple > 0
-        ? winRate * (avgWin / rMultiple) - (1 - winRate)
-        : Infinity;
-    const netExpectancyBts = pair.totalRealizedPnlNet / total;
-    // Daily-binned net PnL for mean/std ratio (dimensionful — not a Sharpe ratio)
-    const dayBuckets = {};
-    for (const r of pnls) {
-        const day = r.exitTime.slice(0, 10);
-        dayBuckets[day] = (dayBuckets[day] || 0) + r.pnlNet;
-    }
-    const dailyRets = Object.values(dayBuckets);
-    const nDays = dailyRets.length;
-    const meanDailyRet = nDays > 0 ? dailyRets.reduce((s, v) => s + v, 0) / nDays : 0;
-    const dailyVar = nDays > 0
-        ? dailyRets.reduce((s, v) => s + (v - meanDailyRet) ** 2, 0) / nDays
-        : 0;
-    const dailyStd = Math.sqrt(dailyVar);
-    const annFactor = Math.sqrt(365);
-    const dailyPnlRatio = dailyStd > 0 ? (meanDailyRet / dailyStd) * annFactor : 0;
-    // Downside deviation uses only negative returns; same N denominator
-    const downsideVar = nDays > 0
-        ? dailyRets.reduce((s, v) => s + (v < 0 ? v * v : 0), 0) / nDays
-        : 0;
-    const downsideStd = Math.sqrt(downsideVar);
-    const dailyDownsideRatio = downsideStd > 0 ? (meanDailyRet / downsideStd) * annFactor : 0;
-    // Fills-per-order distribution (grouped by sell order)
-    const fillCounts = [];
-    const orderMap = new Map();
-    for (const r of pnls) {
-        orderMap.set(r.exitOrderId, (orderMap.get(r.exitOrderId) || 0) + 1);
-    }
-    for (const c of orderMap.values())
-        fillCounts.push(c);
-    const sellOrdersFilled = orderMap.size;
-    const fillsPerOrderMean = sellOrdersFilled > 0
-        ? fillCounts.reduce((s, v) => s + v, 0) / sellOrdersFilled
-        : 0;
-    const fillsPerOrderMax = sellOrdersFilled > 0
-        ? fillCounts.reduce((a, b) => Math.max(a, b), 0)
-        : 0;
-    const sortedCounts = [...fillCounts].sort((a, b) => a - b);
-    const fillsPerOrderMedian = sellOrdersFilled > 0 ? percentile(sortedCounts, 50) : 0;
-    const oneShotOrderRatio = sellOrdersFilled > 0
-        ? fillCounts.filter(c => c === 1).length / sellOrdersFilled
-        : 0;
-    const fillsPerDay = nDays > 0 ? total / nDays : 0;
-    const avgVolumePerDay = nDays > 0 ? (pair.totalBuyQuote + pair.totalSellQuote) / nDays : 0;
-    // Avg hold duration
-    let totalHours = 0;
-    let hourCount = 0;
-    for (const r of pnls) {
-        const entry = new Date(r.entryTime).getTime();
-        const exit = new Date(r.exitTime).getTime();
-        if (!isNaN(entry) && !isNaN(exit) && exit > entry) {
-            totalHours += (exit - entry) / 3600000;
-            hourCount++;
-        }
-    }
-    const avgHoldHours = hourCount > 0 ? totalHours / hourCount : 0;
-    // Max consecutive wins / losses (aggregated by exit order)
-    const orderPnls = new Map();
-    for (const r of pnls) {
-        const existing = orderPnls.get(r.exitOrderId);
-        if (existing) {
-            existing.pnl += r.pnl;
-        }
-        else {
-            orderPnls.set(r.exitOrderId, { pnl: r.pnl, time: r.exitTime });
-        }
-    }
-    const orderResults = [...orderPnls.values()].sort((a, b) => new Date(a.time).getTime() - new Date(b.time).getTime());
-    let consecW = 0, consecL = 0;
-    let maxW = 0, maxL = 0;
-    for (const { pnl } of orderResults) {
-        if (pnl > 0) {
-            consecW++;
-            consecL = 0;
-            maxW = Math.max(maxW, consecW);
-        }
-        else if (pnl < 0) {
-            consecL++;
-            consecW = 0;
-            maxL = Math.max(maxL, consecL);
-        }
-        else {
-            consecW = 0;
-            consecL = 0;
-        }
-    }
-    // ─── Max Drawdown + Recovery Time ───────────────────────────────────
-    const STABILITY_TRADES = 3;
-    const MIN_TRADES_FOR_PEAK = 10; // backstop for monotonic equity curves
-    const chronological = [...pnls].sort((a, b) => new Date(a.exitTime).getTime() - new Date(b.exitTime).getTime());
-    let equity = 0, peak = 0, mddPct = 0;
-    let maxRecoveryDays = 0;
-    let isOngoingRecovery = false;
-    let currentDrawdownDays = 0;
-    let drawdownStartTime = 0;
-    let troughTime = 0;
-    let currentTroughEquity = Infinity;
-    let hadStablePeak = false;
-    let tradesSincePeakSet = 0;
-    let hasPrePeakEquity = false;
-    let prePeakMinEquity = 0;
-    let totalTradesProcessed = 0;
-    for (const r of chronological) {
-        totalTradesProcessed++;
-        equity += r.pnlNet;
-        if (equity > peak) {
-            if (troughTime > 0 && hadStablePeak) {
-                const recoveryDays = (new Date(r.exitTime).getTime() - troughTime) / 86400000;
-                if (recoveryDays > maxRecoveryDays)
-                    maxRecoveryDays = recoveryDays;
-            }
-            peak = equity;
-            tradesSincePeakSet = 0;
-            currentTroughEquity = Infinity;
-            troughTime = 0;
-            drawdownStartTime = 0;
-        }
-        else {
-            tradesSincePeakSet++;
-            if (tradesSincePeakSet >= STABILITY_TRADES) {
-                hadStablePeak = true;
-            }
-        }
-        if (!hadStablePeak && totalTradesProcessed >= MIN_TRADES_FOR_PEAK) {
-            hadStablePeak = true;
-        }
-        if (hadStablePeak && equity < peak && peak > 0) {
-            if (drawdownStartTime === 0)
-                drawdownStartTime = new Date(r.exitTime).getTime();
-            if (equity < currentTroughEquity) {
-                currentTroughEquity = equity;
-                troughTime = new Date(r.exitTime).getTime();
-            }
-            const dd = (equity - peak) / peak;
-            if (dd < mddPct)
-                mddPct = dd;
-        }
-        if (peak > 0 && !hadStablePeak) {
-            if (!hasPrePeakEquity || equity < prePeakMinEquity) {
-                prePeakMinEquity = equity;
-                hasPrePeakEquity = true;
-            }
-        }
-    }
-    if (drawdownStartTime > 0 && hadStablePeak) {
-        const lastTime = new Date(chronological[chronological.length - 1].exitTime).getTime();
-        currentDrawdownDays = (lastTime - drawdownStartTime) / 86400000;
-        isOngoingRecovery = true;
-        if (currentDrawdownDays > maxRecoveryDays) {
-            maxRecoveryDays = currentDrawdownDays;
-        }
-    }
-    if (hadStablePeak) {
-        mddPct *= 100;
-    }
-    else {
-        mddPct = hasPrePeakEquity ? prePeakMinEquity : 0;
-    }
-    // Payoff distribution stats
-    const pnlPcts = [...pnls.map(r => r.pnlPct)].sort((a, b) => a - b);
-    const medianPnlPct = percentile(pnlPcts, 50);
-    const p25PnlPct = percentile(pnlPcts, 25);
-    const p75PnlPct = percentile(pnlPcts, 75);
-    const absAvgLoss = Math.abs(avgLoss);
-    let rValues = [];
-    if (absAvgLoss > 0) {
-        rValues = pnls.map(r => r.pnl / absAvgLoss).sort((a, b) => a - b);
-    }
-    const medianR = rValues.length > 0 ? percentile(rValues, 50) : 0;
-    const pctRGreater1 = rValues.length > 0 ? rValues.filter(r => r > 1).length / rValues.length : 0;
-    const pctRGreater2 = rValues.length > 0 ? rValues.filter(r => r > 2).length / rValues.length : 0;
-    const pctRLessNeg1 = rValues.length > 0 ? rValues.filter(r => r < -1).length / rValues.length : 0;
-    const bestTradePct = pnlPcts.length > 0 ? pnlPcts[pnlPcts.length - 1] : 0;
-    const worstTradePct = pnlPcts.length > 0 ? pnlPcts[0] : 0;
-    return {
-        totalLots: total,
-        winRate,
-        profitFactor,
-        avgWin,
-        avgLoss,
-        avgWinLossRatio,
-        expectancyBts,
-        expectancyPct,
-        expectancyR,
-        netExpectancyBts,
-        dailyPnlRatio,
-        dailyDownsideRatio,
-        feeDragPct,
-        maxConsecWins: maxW,
-        maxConsecLosses: maxL,
-        avgHoldHours,
-        limitOrderRatio: total > 0 ? totalMakerLegs / (total * 2) : 0,
-        bestTradePct,
-        worstTradePct,
-        mddPct,
-        mddHadStablePeak: hadStablePeak,
-        isOngoingRecovery,
-        currentDrawdownDays,
-        maxRecoveryDays,
-        medianPnlPct,
-        p25PnlPct,
-        p75PnlPct,
-        medianR,
-        pctRGreater1,
-        pctRGreater2,
-        pctRLessNeg1,
-        sellOrdersFilled,
-        fillsPerOrderMean,
-        fillsPerOrderMedian,
-        fillsPerOrderMax,
-        oneShotOrderRatio,
-        fillsPerDay,
-        avgVolumePerDay,
-    };
-}
-function printMetrics(pairs) {
-    for (const pair of pairs) {
-        if (pair.realizedPnls.length === 0)
-            continue;
-        const m = computeMetrics(pair);
-        const pairLabel = `${fmtAsset(pair.baseAsset)}/${fmtAsset(pair.quoteAsset)}`;
-        console.log('');
-        console.log(` ── ${pairLabel} — Performance Metrics`);
-        console.log('');
-        // Edge
-        console.log(`  Win Rate:             ${(m.winRate * 100).toFixed(1)}%`);
-        console.log(`  Profit Factor:        ${m.profitFactor === Infinity ? '∞' : m.profitFactor.toFixed(2)}`);
-        const mktFeeStr = pair.totalMarketFees > 0.0001 ? ` (market ${fmt(pair.totalMarketFees, 4)})` : '';
-        const blkFeeStr = pair.totalBlockchainFees > 0.0001 ? ` (op ${fmt(pair.totalBlockchainFees, 4)} BTS)` : '';
-        console.log(`  Fee Drag:             ${m.feeDragPct > 0 ? m.feeDragPct.toFixed(2) + '% of gross profit' + mktFeeStr + blkFeeStr : '—'}`);
-        console.log(`  Avg Win / Avg Loss:   ${m.avgWinLossRatio === Infinity ? '∞' : m.avgWinLossRatio.toFixed(2)}`);
-        const qSymbol = fmtAsset(pair.quoteAsset);
-        console.log(`  Expectancy (gross):   ${fmt(m.expectancyBts, 4)} ${qSymbol} (${fmtPct(m.expectancyPct)}) per trade`);
-        const rDisplay = m.expectancyR === Infinity ? '∞' : m.expectancyR.toFixed(3) + 'R';
-        console.log(`  Expectancy (R):       ${rDisplay}`);
-        console.log(`  Expectancy (net):     ${fmt(m.netExpectancyBts, 4)} ${qSymbol} per trade`);
-        console.log('');
-        // Edge quality
-        console.log(`  Median R:             ${m.medianR.toFixed(2)}`);
-        console.log(`  Trades > 1R / > 2R:   ${(m.pctRGreater1 * 100).toFixed(1)}% / ${(m.pctRGreater2 * 100).toFixed(1)}%`);
-        console.log(`  Trades < -1R:         ${(m.pctRLessNeg1 * 100).toFixed(1)}%`);
-        console.log('');
-        // PnL distribution
-        console.log(`  Median PnL:           ${fmtPct(m.medianPnlPct)}`);
-        console.log(`  P25 / P75:            ${fmtPct(m.p25PnlPct)} / ${fmtPct(m.p75PnlPct)}`);
-        console.log(`  Best / Worst Trade:   ${fmtPct(m.bestTradePct)} / ${fmtPct(m.worstTradePct)}`);
-        console.log('');
-        // Risk-adjusted (dimensionful — based on absolute daily PnL, not % returns)
-        console.log(`  Sharpe (ann):         ${m.dailyPnlRatio.toFixed(2)}`);
-        console.log(`  Sortino (ann):        ${m.dailyDownsideRatio.toFixed(2)}`);
-        console.log('');
-        // Tail risk
-        if (m.mddHadStablePeak) {
-            console.log(`  Max Drawdown:         ${fmtPct(m.mddPct)}`);
-        }
-        else {
-            console.log(`  Min Equity:            ${fmt(m.mddPct, 4)} ${fmtAsset(pair.quoteAsset)}`);
-        }
-        const recLabel = m.maxRecoveryDays > 0 ? m.maxRecoveryDays.toFixed(1) + ' days' + (m.isOngoingRecovery ? ' (ongoing)' : '') : '—';
-        console.log(`  Max Recovery Time:    ${recLabel}`);
-        if (m.currentDrawdownDays > 0) {
-            console.log(`  Current Drawdown:     ${m.currentDrawdownDays.toFixed(1)} days (active)`);
-        }
-        console.log('');
-        // Behavioral
-        console.log(`  Max Consecutive W/L:  ${m.maxConsecWins} / ${m.maxConsecLosses}`);
-        const holdDisplay = m.avgHoldHours > 0 ? m.avgHoldHours.toFixed(1) : '—';
-        console.log(`  Avg hold time:        ${holdDisplay} hours`);
-        console.log(`  Maker / Taker:        ${(m.limitOrderRatio * 100).toFixed(1)}% / ${((1 - m.limitOrderRatio) * 100).toFixed(1)}%`);
-        console.log('');
-        // Activity
-        console.log(`  Sell orders filled:   ${m.sellOrdersFilled}`);
-        console.log(`  Partial fills/order:  ${m.fillsPerOrderMean.toFixed(2)} mean, ${m.fillsPerOrderMedian.toFixed(1)} med, ${m.fillsPerOrderMax} max`);
-        console.log(`  One-shot orders:      ${(m.oneShotOrderRatio * 100).toFixed(0)}%`);
-        console.log(`  Fills/day:            ${m.fillsPerDay.toFixed(2)}`);
-        console.log(`  Avg vol/day:          ${fmt(m.avgVolumePerDay, 2)} ${fmtAsset(pair.quoteAsset)}`);
-        console.log('');
-    }
-    // Grand totals grouped by quote asset
-    const quoteGroups = new Map();
-    for (const p of pairs) {
-        const q = p.quoteAsset;
-        if (!quoteGroups.has(q))
-            quoteGroups.set(q, []);
-        quoteGroups.get(q).push(p);
-    }
-    if (pairs.length > 1 && quoteGroups.size > 0) {
-        for (const [quoteAsset, group] of quoteGroups) {
-            const totalLots = group.reduce((s, p) => s + p.realizedPnls.length, 0);
-            const totalNet = group.reduce((s, p) => s + p.totalRealizedPnlNet, 0);
-            const totalMktFees = group.reduce((s, p) => s + p.totalMarketFees, 0);
-            const totalBlkFees = group.reduce((s, p) => s + p.totalBlockchainFees, 0);
-            const qSymbol = fmtAsset(quoteAsset);
-            console.log(` ── TOTAL (${qSymbol}) — ${group.length} pair(s)`);
-            console.log(`    Lots:      ${totalLots}`);
-            const feeParts = [];
-            if (totalMktFees > 0.0001)
-                feeParts.push(`market ${fmt(totalMktFees, 4)} ${qSymbol}`);
-            if (totalBlkFees > 0.0001)
-                feeParts.push(`op ${fmt(totalBlkFees, 4)} BTS`);
-            const feeSuffix = feeParts.length > 0 ? `  (${feeParts.join(', ')})` : '';
-            console.log(`    Net PnL:   ${fmtAsset(quoteAsset)} ${fmt(totalNet, 4)}${feeSuffix}`);
-            console.log('');
-        }
-    }
-}
-// ─── CSV Export ──────────────────────────────────────────────────────────────
-function exportCsv(pairs, filePath) {
-    const esc = (v) => { const s = String(v); return /[,"\n]/.test(s) ? '"' + s.replace(/"/g, '""') + '"' : s; };
-    const lines = ['time,orderId,direction,baseAsset,quoteAsset,baseAmount,quoteAmount,price,isMaker,marketFeeReal,marketFeeAsset'];
-    for (const pair of pairs) {
-        for (const t of [...pair.buys, ...pair.sells].sort((a, b) => a.sequence - b.sequence)) {
-            lines.push([
-                esc(t.time),
-                esc(t.orderId),
-                esc(t.direction),
-                esc(t.baseAsset),
-                esc(t.quoteAsset),
-                t.baseAmount,
-                t.quoteAmount,
-                t.price,
-                t.isMaker ? '1' : '0',
-                t.marketFeeReal,
-                esc(t.marketFeeAsset),
-            ].join(','));
-        }
-    }
-    node_fs_1.default.writeFileSync(filePath, lines.join('\n'), 'utf-8');
-    console.log(`  Trades exported to ${filePath}`);
-}
-// ─── JSON Export ─────────────────────────────────────────────────────────────
-function exportJson(accountId, start, end, pairs, filePath) {
-    const data = {
-        accountId,
-        period: { start, end },
-        pairs: pairs.map(p => ({
-            baseAsset: p.baseAsset,
-            quoteAsset: p.quoteAsset,
-            summary: {
-                totalBuyBase: p.totalBuyBase,
-                totalSellBase: p.totalSellBase,
-                totalBuyQuote: p.totalBuyQuote,
-                totalSellQuote: p.totalSellQuote,
-                netPosition: p.netPosition,
-                totalRealizedPnl: p.totalRealizedPnl,
-                totalMarketFees: p.totalMarketFees,
-                totalBlockchainFees: p.totalBlockchainFees,
-                totalRealizedPnlNet: p.totalRealizedPnlNet,
-            },
-            realizedPnls: p.realizedPnls.map(r => ({
-                ...r,
-                marketFeeEntry: r.marketFeeEntry,
-                marketFeeExit: r.marketFeeExit,
-                feeBts: r.feeBts,
-                pnlNet: r.pnlNet,
-                pnlNetPct: r.pnlNetPct,
-            })),
-            totalBuys: p.buys.length,
-            totalSells: p.sells.length,
-        })),
-    };
-    node_fs_1.default.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
-    console.log(`  Full analysis exported to ${filePath}`);
-}
-// ─── Main ────────────────────────────────────────────────────────────────────
-async function run() {
-    const opts = parseArgs();
-    let accountId = opts.accountId;
-    if (opts.lookup) {
-        const resolved = await resolveAccountId(accountId, opts.node);
-        if (!resolved) {
-            console.error(`  Could not resolve "${accountId}" to an account ID`);
-            process.exit(1);
-        }
-        accountId = resolved;
-    }
-    // Build time range
-    const now = new Date();
-    let gte, lte;
-    if (opts.start && opts.end) {
-        gte = opts.start;
-        lte = opts.end;
-    }
-    else if (opts.start) {
-        gte = opts.start;
-        lte = now.toISOString();
-    }
-    else {
-        const hours = opts.hours || 168;
-        const start = new Date(now.getTime() - hours * 3600 * 1000);
-        gte = start.toISOString();
-        lte = now.toISOString();
-    }
-    // Ensure times end with Z for ES
-    if (!gte.endsWith('Z'))
-        gte += gte.includes('T') ? 'Z' : 'T00:00:00Z';
-    if (!lte.endsWith('Z'))
-        lte += lte.includes('T') ? 'Z' : 'T00:00:00Z';
-    const KIBANA_CFG = { timeout: 60000 };
-    const fills = await fetchAllFills(KIBANA_CFG, accountId, gte, lte);
-    if (fills.length === 0) {
-        console.log('  No fills found in the specified time range.');
-        process.exit(0);
-    }
-    // Resolve unknown asset precisions from blockchain
-    await resolveAssetPrecisions(fills, opts.node);
-    // Classify fills
-    const { trades, pairs } = classifyFills(fills, opts.asset);
-    if (trades.length === 0) {
-        console.log('  No trades could be classified (check asset filter or time range).');
-        process.exit(0);
-    }
-    console.log(`Account:  ${accountId}`);
-    console.log(`Period:   ${gte.slice(0, 10)}  →  ${lte.slice(0, 10)}`);
-    console.log(`Pairs:    ${pairs.size}, ${trades.length} classified trades`);
-    const hasCrossPair = [...pairs].some(p => p.split(':')[1] !== BTS_ID);
-    if (hasCrossPair) {
-        console.log(`  Note: cross-pair trades (non-BTS quote) are included but PnL is in the pair's quote asset.`);
-    }
-    console.log('');
-    // Override blockchain fee from CLI if provided
-    if (opts.feePerOrder)
-        BLOCKCHAIN_FEE_PER_FILL = opts.feePerOrder;
-    // Analyze each pair
-    const pairMap = new Map();
-    for (const t of trades) {
-        const pairKey = `${t.baseAsset}:${t.quoteAsset}`;
-        if (!pairMap.has(pairKey))
-            pairMap.set(pairKey, []);
-        pairMap.get(pairKey).push(t);
-    }
-    const analyses = [];
-    for (const [key, pairTrades] of pairMap) {
-        const analysis = analyzePair(pairTrades, opts.matchMode);
-        analyses.push(analysis);
-        if (opts.verbose) {
-            const [base, quote] = key.split(':');
-            console.log(`  ${fmtAsset(base)}/${fmtAsset(quote)}: ${pairTrades.filter(t => t.direction === 'buy').length} buys, ${pairTrades.filter(t => t.direction === 'sell').length} sells, ${analysis.realizedPnls.length} matched lots`);
-        }
-    }
-    // Sort pairs by volume (total quote)
-    analyses.sort((a, b) => (b.totalBuyQuote + b.totalSellQuote) - (a.totalBuyQuote + a.totalSellQuote));
-    // Output: summaries → grand total → per-match detail
-    printSummary(analyses, accountId, gte, lte, opts.matchMode);
-    if (opts.showPnlDetail) {
-        printPnlDetail(analyses);
-    }
-    printMetrics(analyses);
-    if (opts.csv) {
-        exportCsv(analyses, opts.csv);
-    }
-    if (opts.json) {
-        exportJson(accountId, gte, lte, analyses, opts.json);
-    }
-}
-if (require.main === module) {
-    run().then(() => process.exit(0)).catch(e => {
-        console.error('\n[fatal]', e.message);
-        if (process.env.DEBUG)
-            console.error(e.stack);
-        process.exit(1);
-    });
-}
-//# sourceMappingURL=trade_profitability.js.map