aiden-shared-calculations-unified 1.0.0

package/calculations/speculators/leverage_per_asset.js

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview Calculates leverage usage per instrument for speculators.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class LeveragePerAsset {
+    constructor() {
+        this.leverageData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, userId) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            for (const position of portfolioData.PublicPositions) {
+                const instrumentId = position.InstrumentID;
+                const leverage = position.Leverage;
+
+                if (!this.leverageData[instrumentId]) {
+                    this.leverageData[instrumentId] = {};
+                }
+                this.leverageData[instrumentId][leverage] = (this.leverageData[instrumentId][leverage] || 0) + 1;
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.leverageData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = this.leverageData[instrumentId];
+        }
+        if (Object.keys(result).length === 0) return {};
+        return {
+            leverage_per_asset: result
+        };
+    }
+
+    reset() {
+        this.leverageData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = LeveragePerAsset;

package/calculations/speculators/leverage_per_sector.js

@@ -0,0 +1,45 @@
+const { getInstrumentSectorMap } = require('../../utils/sector_mapping_provider');
+
+/**
+ * @fileoverview Calculates leverage usage per sector for speculators.
+ */
+
+class LeveragePerSector {
+    constructor() {
+        this.positions = [];
+    }
+
+    process(portfolioData, userId) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            this.positions.push(...portfolioData.PublicPositions);
+        }
+    }
+
+    async getResult() {
+        if (this.positions.length === 0) return {};
+
+        const sectorMap = await getInstrumentSectorMap();
+        const leverageData = {};
+
+        for (const position of this.positions) {
+            const instrumentId = position.InstrumentID;
+            const sector = sectorMap[instrumentId] || 'N/A';
+            const leverage = position.Leverage;
+
+            if (!leverageData[sector]) {
+                leverageData[sector] = {};
+            }
+            leverageData[sector][leverage] = (leverageData[sector][leverage] || 0) + 1;
+        }
+
+        return {
+            leverage_per_sector: leverageData
+        };
+    }
+
+    reset() {
+        this.positions = [];
+    }
+}
+
+module.exports = LeveragePerSector;

package/calculations/speculators/risk_appetite_change.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Calculates the change in risk appetite for speculators based on stop-loss distance.
+ */
+
+class RiskAppetiteChange {
+    constructor() {
+        this.totalYesterdaySLDistance = 0;
+        this.totalTodaySLDistance = 0;
+        this.userCount = 0;
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        if (!todayPortfolio || !yesterdayPortfolio || !todayPortfolio.PublicPositions || !yesterdayPortfolio.PublicPositions) {
+            return;
+        }
+
+        const yesterdayAvgDistance = this.calculateAverageSLDistance(yesterdayPortfolio.PublicPositions);
+        const todayAvgDistance = this.calculateAverageSLDistance(todayPortfolio.PublicPositions);
+
+        if (yesterdayAvgDistance !== null && todayAvgDistance !== null) {
+            this.totalYesterdaySLDistance += yesterdayAvgDistance;
+            this.totalTodaySLDistance += todayAvgDistance;
+            this.userCount++;
+        }
+    }
+
+    calculateAverageSLDistance(positions) {
+        let totalDistance = 0;
+        let count = 0;
+        for (const pos of positions) {
+            if (pos.StopLossRate > 0.0001 && pos.OpenRate > 0) {
+                const distance = pos.IsBuy ? pos.OpenRate - pos.StopLossRate : pos.StopLossRate - pos.OpenRate;
+                if (distance > 0) {
+                    totalDistance += (distance / pos.OpenRate) * 100;
+                    count++;
+                }
+            }
+        }
+        return count > 0 ? totalDistance / count : null;
+    }
+
+    getResult() {
+        if (this.userCount === 0) return {};
+        const avgYesterday = this.totalYesterdaySLDistance / this.userCount;
+        const avgToday = this.totalTodaySLDistance / this.userCount;
+
+        return {
+            average_stop_loss_distance_yesterday: avgYesterday,
+            average_stop_loss_distance_today: avgToday,
+            change_in_risk_appetite: avgToday - avgYesterday,
+        };
+    }
+}
+
+module.exports = RiskAppetiteChange;

package/calculations/speculators/risk_reward_ratio_per_asset.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Calculates the average risk-reward ratio per asset from speculator positions.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class RiskRewardRatioPerAsset {
+    constructor() {
+        this.rrData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, userId, context) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            for (const position of portfolioData.PublicPositions) {
+                if (position.TakeProfitRate > 0 && position.StopLossRate > 0) {
+                    const instrumentId = position.InstrumentID;
+                    const openRate = position.OpenRate;
+                    const potentialReward = Math.abs(position.TakeProfitRate - openRate);
+                    const potentialRisk = Math.abs(openRate - position.StopLossRate);
+
+                    if (potentialRisk > 0) {
+                        const ratio = potentialReward / potentialRisk;
+                        if (!this.rrData[instrumentId]) {
+                            this.rrData[instrumentId] = { ratio_sum: 0, count: 0 };
+                        }
+                        this.rrData[instrumentId].ratio_sum += ratio;
+                        this.rrData[instrumentId].count++;
+                    }
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.rrData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            const data = this.rrData[instrumentId];
+
+            // REFACTOR: Perform the final calculation directly.
+            if (data.count > 0) {
+                result[ticker] = {
+                    average_ratio: data.ratio_sum / data.count
+                };
+            }
+        }
+
+        return result;
+    }
+
+    reset() {
+        this.rrData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = RiskRewardRatioPerAsset;

package/calculations/speculators/speculator_asset_sentiment.js

@@ -0,0 +1,81 @@
+/**
+ * Aggregates and calculates average P/L, leverage, SL, and TP data for longs vs. shorts
+ * on a per-asset basis for speculators.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class SpeculatorAssetSentiment {
+    constructor() {
+        this.assets = {};
+        this.mappings = null;
+    }
+
+    _initAsset(instrumentId) {
+        if (!this.assets[instrumentId]) {
+            this.assets[instrumentId] = {
+                long: { count: 0, pnl_sum: 0, leverage_sum: 0, sl_rate_sum: 0, tp_rate_sum: 0 },
+                short: { count: 0, pnl_sum: 0, leverage_sum: 0, sl_rate_sum: 0, tp_rate_sum: 0 }
+            };
+        }
+    }
+
+    process(portfolioData, userId, context) {
+        const positions = portfolioData.PublicPositions;
+        if (!positions || !Array.isArray(positions)) return;
+
+        for (const position of positions) {
+            const instrumentId = position.InstrumentID;
+            if (!instrumentId) continue;
+
+            this._initAsset(instrumentId);
+
+            const direction = position.IsBuy ? 'long' : 'short';
+            const stats = this.assets[instrumentId][direction];
+
+            stats.count++;
+            stats.pnl_sum += position.NetProfit;
+            stats.leverage_sum += position.Leverage;
+
+            if (position.StopLossRate && position.StopLossRate > 0) {
+                stats.sl_rate_sum += position.StopLossRate;
+            }
+            if (position.TakeProfitRate && position.TakeProfitRate > 0) {
+                stats.tp_rate_sum += position.TakeProfitRate;
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+
+        const finalResult = {};
+
+        for (const instrumentId in this.assets) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            finalResult[ticker] = {};
+
+            for (const direction in this.assets[instrumentId]) {
+                const stats = this.assets[instrumentId][direction];
+                // REFACTOR: Perform final calculations.
+                finalResult[ticker][direction] = {
+                    count: stats.count,
+                    average_pnl: stats.count > 0 ? stats.pnl_sum / stats.count : 0,
+                    average_leverage: stats.count > 0 ? stats.leverage_sum / stats.count : 0,
+                    average_sl_rate: stats.count > 0 ? stats.sl_rate_sum / stats.count : 0,
+                    average_tp_rate: stats.count > 0 ? stats.tp_rate_sum / stats.count : 0,
+                };
+            }
+        }
+        
+        return finalResult;
+    }
+
+    reset() {
+        this.assets = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = SpeculatorAssetSentiment;

package/calculations/speculators/speculator_danger_zone.js

@@ -0,0 +1,58 @@
+/**
+ * Counts speculator positions that are close to their stop loss ("Danger Zone").
+ * This example defines "close" as within 5% of the current rate.
+ */
+class SpeculatorDangerZone {
+    constructor() {
+        this.danger_zone = {};
+    }
+
+    _initAsset(ticker) {
+        if (!this.danger_zone[ticker]) {
+            this.danger_zone[ticker] = { long_danger_count: 0, short_danger_count: 0 };
+        }
+    }
+
+    process(portfolioData, userId, context) {
+        const { instrumentMappings } = context;
+
+        // FIX: Use the correct PublicPositions property for speculators
+        const positions = portfolioData.PublicPositions;
+        if (!positions || !Array.isArray(positions)) return;
+
+        for (const position of positions) {
+            // Ensure position has a valid stop loss and rate
+            if (!position.StopLossRate || position.StopLossRate <= 0 || !position.CurrentRate) {
+                continue;
+            }
+
+            // FIX: Use the correct PascalCase InstrumentID
+            const ticker = instrumentMappings[position.InstrumentID];
+            if (!ticker) continue;
+
+            this._initAsset(ticker);
+
+            let distance_percent = 0;
+            // FIX: Use the correct PascalCase IsBuy
+            if (position.IsBuy) {
+                // Long position: Danger if SL is just below current rate
+                distance_percent = (position.CurrentRate - position.StopLossRate) / position.CurrentRate;
+                if (distance_percent > 0 && distance_percent < 0.05) {
+                    this.danger_zone[ticker].long_danger_count++;
+                }
+            } else {
+                // Short position: Danger if SL is just above current rate
+                distance_percent = (position.StopLossRate - position.CurrentRate) / position.CurrentRate;
+                if (distance_percent > 0 && distance_percent < 0.05) {
+                    this.danger_zone[ticker].short_danger_count++;
+                }
+            }
+        }
+    }
+
+    getResult() {
+        return this.danger_zone;
+    }
+}
+
+module.exports = SpeculatorDangerZone;

package/calculations/speculators/stop_loss_distance_by_sector_short_long_breakdown.js

@@ -0,0 +1,91 @@
+/**
+ * @fileoverview Calculates the average stop loss distance (percent and value)
+ * for long and short positions, grouped by SECTOR.
+ */
+const { getInstrumentSectorMap } = require('../../utils/sector_mapping_provider');
+
+class StopLossDistanceBySector {
+    constructor() {
+        this.instrumentData = {};
+        this.instrumentToSector = null;
+    }
+
+    process(portfolioData, userId) {
+        if (!portfolioData || !portfolioData.PublicPositions) return;
+
+        for (const position of portfolioData.PublicPositions) {
+            const { InstrumentID, Leverage, StopLossRate, CurrentRate, IsBuy } = position;
+            if (Leverage <= 1 || StopLossRate <= 0.0001 || CurrentRate <= 0) continue;
+
+            const distance_value = IsBuy ? CurrentRate - StopLossRate : StopLossRate - CurrentRate;
+            const distance_percent = (distance_value / CurrentRate) * 100;
+
+            if (distance_percent > 0) {
+                const posType = IsBuy ? 'long' : 'short';
+                if (!this.instrumentData[InstrumentID]) this.instrumentData[InstrumentID] = {};
+                if (!this.instrumentData[InstrumentID][posType]) {
+                    this.instrumentData[InstrumentID][posType] = {
+                        distance_percent_sum: 0,
+                        distance_value_sum: 0,
+                        count: 0
+                    };
+                }
+                const agg = this.instrumentData[InstrumentID][posType];
+                agg.distance_percent_sum += distance_percent;
+                agg.distance_value_sum += distance_value;
+                agg.count++;
+            }
+        }
+    }
+
+    async getResult() {
+        if (Object.keys(this.instrumentData).length === 0) return {};
+        if (!this.instrumentToSector) {
+            this.instrumentToSector = await getInstrumentSectorMap();
+        }
+
+        const sectorData = {};
+        for (const instrumentId in this.instrumentData) {
+            const sector = this.instrumentToSector[instrumentId] || 'N/A';
+            if (!sectorData[sector]) sectorData[sector] = {};
+
+            for (const posType in this.instrumentData[instrumentId]) {
+                if (!sectorData[sector][posType]) {
+                    sectorData[sector][posType] = {
+                        distance_percent_sum: 0,
+                        distance_value_sum: 0,
+                        count: 0
+                    };
+                }
+                const source = this.instrumentData[instrumentId][posType];
+                const target = sectorData[sector][posType];
+                target.distance_percent_sum += source.distance_percent_sum;
+                target.distance_value_sum += source.distance_value_sum;
+                target.count += source.count;
+            }
+        }
+
+        const result = {};
+        for (const sector in sectorData) {
+            result[sector] = {};
+            for (const posType in sectorData[sector]) {
+                const data = sectorData[sector][posType];
+                // REFACTOR: Perform final calculation and return in standardized format.
+                if (data.count > 0) {
+                    result[sector][posType] = {
+                        average_distance_percent: data.distance_percent_sum / data.count,
+                        average_distance_value: data.distance_value_sum / data.count,
+                        count: data.count
+                    };
+                }
+            }
+        }
+        return result;
+    }
+
+    reset() {
+        this.instrumentData = {};
+    }
+}
+
+module.exports = StopLossDistanceBySector;

package/calculations/speculators/stop_loss_distance_by_ticker_short_long_breakdown.js

@@ -0,0 +1,73 @@
+/**
+ * @fileoverview Calculates the average stop loss distance (percent and value)
+ * for long and short positions, grouped by TICKER.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class StopLossDistanceByTicker {
+    constructor() {
+        this.instrumentData = {};
+        this.instrumentToTicker = null;
+    }
+
+    process(portfolioData, userId) {
+        if (!portfolioData || !portfolioData.PublicPositions) return;
+
+        for (const position of portfolioData.PublicPositions) {
+            const { InstrumentID, Leverage, StopLossRate, CurrentRate, IsBuy } = position;
+            if (Leverage <= 1 || StopLossRate <= 0.0001 || CurrentRate <= 0) continue;
+
+            const distance_value = IsBuy ? CurrentRate - StopLossRate : StopLossRate - CurrentRate;
+            const distance_percent = (distance_value / CurrentRate) * 100;
+
+            if (distance_percent > 0) {
+                const posType = IsBuy ? 'long' : 'short';
+                if (!this.instrumentData[InstrumentID]) this.instrumentData[InstrumentID] = {};
+                if (!this.instrumentData[InstrumentID][posType]) {
+                    this.instrumentData[InstrumentID][posType] = {
+                        distance_percent_sum: 0,
+                        distance_value_sum: 0,
+                        count: 0
+                    };
+                }
+                const agg = this.instrumentData[InstrumentID][posType];
+                agg.distance_percent_sum += distance_percent;
+                agg.distance_value_sum += distance_value;
+                agg.count++;
+            }
+        }
+    }
+
+    async getResult() {
+        if (Object.keys(this.instrumentData).length === 0) return {};
+        if (!this.instrumentToTicker) {
+            const mappings = await loadInstrumentMappings();
+            this.instrumentToTicker = mappings.instrumentToTicker;
+        }
+
+        const result = {};
+        for (const instrumentId in this.instrumentData) {
+            const ticker = this.instrumentToTicker[instrumentId] || `unknown_${instrumentId}`;
+            if (!result[ticker]) result[ticker] = {};
+
+            for (const posType in this.instrumentData[instrumentId]) {
+                const data = this.instrumentData[instrumentId][posType];
+                // REFACTOR: Perform final calculation and return in standardized format.
+                if (data.count > 0) {
+                    result[ticker][posType] = {
+                        average_distance_percent: data.distance_percent_sum / data.count,
+                        average_distance_value: data.distance_value_sum / data.count,
+                        count: data.count
+                    };
+                }
+            }
+        }
+        return result;
+    }
+
+    reset() {
+        this.instrumentData = {};
+    }
+}
+
+module.exports = StopLossDistanceByTicker;

package/calculations/speculators/stop_loss_per_asset.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Calculates the average stop loss level per asset.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class StopLossPerAsset {
+    constructor() {
+        this.stopLossData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, userId) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            for (const position of portfolioData.PublicPositions) {
+                const instrumentId = position.InstrumentID;
+                const stopLoss = position.StopLossRate;
+
+                if (stopLoss > 0) {
+                    if (!this.stopLossData[instrumentId]) {
+                        this.stopLossData[instrumentId] = { sum: 0, count: 0 };
+                    }
+                    this.stopLossData[instrumentId].sum += stopLoss;
+                    this.stopLossData[instrumentId].count++;
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.stopLossData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            const data = this.stopLossData[instrumentId];
+            
+            // REFACTOR: Perform final calculation directly.
+            if (data.count > 0) {
+                result[ticker] = {
+                    average_stop_loss: data.sum / data.count
+                };
+            }
+        }
+        
+        return result;
+    }
+
+    reset() {
+        this.stopLossData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = StopLossPerAsset;

package/calculations/speculators/take_profit_per_asset.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Calculates the average take profit level per asset.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class TakeProfitPerAsset {
+    constructor() {
+        this.takeProfitData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, userId) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            for (const position of portfolioData.PublicPositions) {
+                const instrumentId = position.InstrumentID;
+                const takeProfit = position.TakeProfitRate;
+
+                if (takeProfit > 0) {
+                    if (!this.takeProfitData[instrumentId]) {
+                        this.takeProfitData[instrumentId] = { sum: 0, count: 0 };
+                    }
+                    this.takeProfitData[instrumentId].sum += takeProfit;
+                    this.takeProfitData[instrumentId].count++;
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.takeProfitData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            const data = this.takeProfitData[instrumentId];
+
+            // REFACTOR: Perform final calculation directly.
+            if (data.count > 0) {
+                result[ticker] = {
+                    average_take_profit: data.sum / data.count
+                };
+            }
+        }
+
+        return result;
+    }
+
+    reset() {
+        this.takeProfitData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = TakeProfitPerAsset;

package/calculations/speculators/tsl_effectiveness.js

@@ -0,0 +1,55 @@
+/**
+ * Compares the average P/L of speculator users who use TSL
+ * vs. those who do not.
+ */
+class TslEffectiveness {
+    constructor() {
+        this.tsl_group = { pnl_sum: 0, count: 0 };
+        this.nontsl_group = { pnl_sum: 0, count: 0 };
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        // Check if user is a speculator and we have both days' data
+        if (todayPortfolio?.context?.userType !== 'speculator' || !yesterdayPortfolio) {
+            return;
+        }
+        
+        // FIX: This calculation is for speculators, so we use PublicPositions
+        const positions = todayPortfolio.PublicPositions;
+        
+        // FIX: Add check to ensure positions is an iterable array
+        if (!positions || !Array.isArray(positions)) {
+            return; 
+        }
+
+        const dailyPnl = todayPortfolio.PortfolioValue - yesterdayPortfolio.PortfolioValue;
+        const usesTSL = positions.some(p => p.IsTslEnabled);
+
+        if (usesTSL) {
+            this.tsl_group.pnl_sum += dailyPnl;
+            this.tsl_group.count++;
+        } else {
+            this.nontsl_group.pnl_sum += dailyPnl;
+            this.nontsl_group.count++;
+        }
+    }
+
+    getResult() {
+        // Return final calculated averages
+        const tsl_avg_pnl = (this.tsl_group.count > 0) ? this.tsl_group.pnl_sum / this.tsl_group.count : 0;
+        const nontsl_avg_pnl = (this.nontsl_group.count > 0) ? this.nontsl_group.pnl_sum / this.nontsl_group.count : 0;
+
+        return {
+            tsl_users: {
+                avg_pnl: tsl_avg_pnl,
+                count: this.tsl_group.count
+            },
+            nontsl_users: {
+                avg_pnl: nontsl_avg_pnl,
+                count: this.nontsl_group.count
+            }
+        };
+    }
+}
+
+module.exports = TslEffectiveness;