aiden-shared-calculations-unified 1.0.37 → 1.0.38

package/calculations/capital_flow/historical/reallocation_increase_percentage.js

@@ -0,0 +1,63 @@
+/**
+ * @fileoverview Calculates the average percentage increase in allocation
+ * specifically towards assets already held on the previous day.
+ */
+
+class ReallocationIncreasePercentage {
+    constructor() {
+        this.accumulatedIncreasePercentage = 0;
+        this.userCount = 0;
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        if (!todayPortfolio || !yesterdayPortfolio || !todayPortfolio.AggregatedPositions || !yesterdayPortfolio.AggregatedPositions) {
+            // Requires AggregatedPositions which contain the 'Invested' percentage
+            return;
+        }
+
+        const yesterdayPositions = new Map(yesterdayPortfolio.AggregatedPositions.map(p => [p.InstrumentID, p]));
+        let userTotalIncreasePercentage = 0;
+
+        for (const todayPos of todayPortfolio.AggregatedPositions) {
+            const yesterdayPos = yesterdayPositions.get(todayPos.InstrumentID);
+
+            // Check if the asset was held yesterday
+            if (yesterdayPos) {
+                // Ensure 'Invested' property exists and is a number
+                const todayInvested = typeof todayPos.Invested === 'number' ? todayPos.Invested : 0;
+                const yesterdayInvested = typeof yesterdayPos.Invested === 'number' ? yesterdayPos.Invested : 0;
+
+                const deltaInvested = todayInvested - yesterdayInvested;
+
+                // Accumulate only the increases
+                if (deltaInvested > 0) {
+                    userTotalIncreasePercentage += deltaInvested;
+                }
+            }
+        }
+
+        // Only count users who had positions on both days for this metric
+        if (yesterdayPortfolio.AggregatedPositions.length > 0 && todayPortfolio.AggregatedPositions.length > 0) {
+           this.accumulatedIncreasePercentage += userTotalIncreasePercentage;
+           this.userCount++;
+        }
+    }
+
+    getResult() {
+        if (this.userCount === 0) {
+            return {};
+        }
+
+        return {
+             // Calculate the final average directly
+            average_reallocation_increase_percentage: this.accumulatedIncreasePercentage / this.userCount
+        };
+    }
+
+    reset() {
+        this.accumulatedIncreasePercentage = 0;
+        this.userCount = 0;
+    }
+}
+
+module.exports = ReallocationIncreasePercentage;

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, yesterdayPortfolio, userId, context) {
+        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, yesterdayPortfolio, userId, context) {
+        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiden-shared-calculations-unified",
-  "version": "1.0.37",
+  "version": "1.0.38",
   "description": "Shared calculation modules for the BullTrackers Computation System.",
   "main": "index.js",
   "files": [