aiden-shared-calculations-unified 1.0.0

package/calculations/sentiment/crowd_conviction_score.js

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview Calculates a "Crowd Conviction" score for each instrument.
+ */
+// CORRECTED PATH: ../utils/ instead of ../../utils/
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+
+class CrowdConvictionScore {
+    // ... (rest of the code is unchanged) ...
+    constructor() {
+        this.convictionData = {};
+        this.mappings = null;
+    }
+
+    async process(todayPortfolio, yesterdayPortfolio, userId) {
+        if (!todayPortfolio) return;
+
+        if(!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+
+        const positions = todayPortfolio.PublicPositions || todayPortfolio.AggregatedPositions;
+        if (!positions) return;
+
+        for (const pos of positions) {
+            const instrumentId = pos.InstrumentID;
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+
+            if (!this.convictionData[ticker]) {
+                this.convictionData[ticker] = {
+                    totalScore: 0,
+                    count: 0,
+                };
+            }
+
+            let score = 0;
+            let weights = 0;
+
+            if (pos.OpenDateTime) {
+                const openTime = new Date(pos.OpenDateTime);
+                const holdingHours = (new Date() - openTime) / (1000 * 60 * 60);
+                score += Math.log(holdingHours + 1);
+                weights += 1;
+            }
+
+            if (pos.StopLossRate > 0 && pos.TakeProfitRate > 0) {
+                const risk = Math.abs(pos.OpenRate - pos.StopLossRate);
+                const reward = Math.abs(pos.TakeProfitRate - pos.OpenRate);
+                if (risk > 0) {
+                    const ratio = reward / risk;
+                    score += ratio * 0.5;
+                    weights += 0.5;
+                }
+            }
+
+            if (pos.Leverage > 1) {
+                score += Math.log(pos.Leverage) * 1.5;
+                weights += 1.5;
+            }
+
+            if (weights > 0) {
+                const finalScore = (score / weights) * 100;
+                this.convictionData[ticker].totalScore += finalScore;
+                this.convictionData[ticker].count++;
+            }
+        }
+    }
+
+    getResult() {
+        const result = {};
+        for (const ticker in this.convictionData) {
+            const data = this.convictionData[ticker];
+            if (data.count > 0) {
+                result[ticker] = data.totalScore / data.count;
+            }
+        }
+        return { crowd_conviction_score: result };
+    }
+}
+
+module.exports = CrowdConvictionScore;

package/calculations/short_and_long_stats/long_position_per_stock.js

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Counts the total number of 'long' (Buy) positions for each instrument.
+ * This provides a simple measure of how many users are holding a long position in a given stock.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class LongPositionPerStock {
+    constructor() {
+        this.longCountByInstrument = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, userId, context) {
+        if (!portfolioData || !portfolioData.AggregatedPositions) {
+            return;
+        }
+
+        for (const position of portfolioData.AggregatedPositions) {
+            if (position.Direction === 'Buy') {
+                const instrumentId = position.InstrumentID;
+                this.longCountByInstrument[instrumentId] = (this.longCountByInstrument[instrumentId] || 0) + 1;
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.longCountByInstrument) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = this.longCountByInstrument[instrumentId];
+        }
+        return { long_positions_by_stock: result };
+    }
+
+    reset() {
+        this.longCountByInstrument = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = LongPositionPerStock;

package/calculations/short_and_long_stats/sentiment_per_stock.js

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Calculates a crowd sentiment score for each instrument by counting long and short positions.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class SentimentPerStock {
+    constructor() {
+        this.sentimentData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, userId, context) {
+        if (!portfolioData || !portfolioData.AggregatedPositions) {
+            return;
+        }
+
+        for (const position of portfolioData.AggregatedPositions) {
+            const instrumentId = position.InstrumentID;
+            if (!this.sentimentData[instrumentId]) {
+                this.sentimentData[instrumentId] = { long_positions: 0, short_positions: 0 };
+            }
+
+            if (position.Direction === 'Buy') {
+                this.sentimentData[instrumentId].long_positions++;
+            } else if (position.Direction === 'Sell') {
+                this.sentimentData[instrumentId].short_positions++;
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.sentimentData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = this.sentimentData[instrumentId];
+        }
+        if (Object.keys(result).length === 0) return {};
+        return { sentiment_by_asset: result };
+    }
+
+    reset() {
+        this.sentimentData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = SentimentPerStock;

package/calculations/short_and_long_stats/short_position_per_stock.js

@@ -0,0 +1,43 @@
+/**
+ * @fileoverview Counts the total number of 'short' (Sell) positions for each instrument.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class ShortPositionPerStock {
+    constructor() {
+        this.shortCountByInstrument = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, userId, context) {
+        if (!portfolioData || !portfolioData.AggregatedPositions) {
+            return;
+        }
+
+        for (const position of portfolioData.AggregatedPositions) {
+            if (position.Direction === 'Sell') {
+                const instrumentId = position.InstrumentID;
+                this.shortCountByInstrument[instrumentId] = (this.shortCountByInstrument[instrumentId] || 0) + 1;
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.shortCountByInstrument) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = this.shortCountByInstrument[instrumentId];
+        }
+        return { short_positions_by_stock: result };
+    }
+
+    reset() {
+        this.shortCountByInstrument = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = ShortPositionPerStock;

package/calculations/short_and_long_stats/total_long_figures.js

@@ -0,0 +1,33 @@
+/**
+ * @fileoverview Calculates the total number of 'long' (Buy) positions across all users and instruments.
+ */
+
+class TotalLongFigures {
+    constructor() {
+        this.totalLongPositions = 0;
+    }
+
+    process(portfolioData, userId, context) {
+        if (portfolioData && portfolioData.AggregatedPositions) {
+            for (const position of portfolioData.AggregatedPositions) {
+                if (position.Direction === 'Buy') {
+                    this.totalLongPositions++;
+                }
+            }
+        }
+    }
+
+    // Change getResult() (lines 20-22) to:
+    getResult() {
+        if (this.totalLongPositions === 0) return {};
+        return {
+            rawTotalLongPositions: this.totalLongPositions
+        };
+    }
+
+    reset() {
+        this.totalLongPositions = 0;
+    }
+}
+
+module.exports = TotalLongFigures;

package/calculations/short_and_long_stats/total_short_figures.js

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview Calculates the total number of 'short' (Sell) positions across all users and instruments.
+ */
+
+class TotalShortFigures {
+    constructor() {
+        this.totalShortPositions = 0;
+    }
+
+    process(portfolioData, userId, context) {
+        if (portfolioData && portfolioData.AggregatedPositions) {
+            for (const position of portfolioData.AggregatedPositions) {
+                // Note: Short positions are indicated by Direction: 'Sell' in this data model
+                if (position.Direction === 'Sell') {
+                    this.totalShortPositions++;
+                }
+            }
+        }
+    }
+
+    // Change getResult() (lines 20-22) to:
+    getResult() {
+        if (this.totalShortPositions === 0) return {};
+        return {
+            rawTotalShortPositions: this.totalShortPositions
+        };
+    }
+
+    reset() {
+        this.totalShortPositions = 0;
+    }
+}
+
+module.exports = TotalShortFigures;

package/calculations/speculators/distance_to_stop_loss_per_leverage.js

@@ -0,0 +1,78 @@
+/**
+ * @fileoverview Calculates the average distance to the stop loss from the current price for
+ * both long and short positions, grouped by asset and leverage level.
+ * It ignores near-zero stop loss values.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class DistanceToStopLossPerLeverage {
+    constructor() {
+        this.stopLossData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, userId) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            for (const position of portfolioData.PublicPositions) {
+                const instrumentId = position.InstrumentID;
+                const leverage = position.Leverage;
+                const stopLossRate = position.StopLossRate;
+                const currentRate = position.CurrentRate;
+                const isBuy = position.IsBuy;
+
+                if (stopLossRate > 0.0001 && currentRate > 0) {
+                    let distance;
+
+                    if (isBuy) {
+                        distance = currentRate - stopLossRate;
+                    } else {
+                        distance = stopLossRate - currentRate;
+                    }
+                    
+                    const distancePercent = (distance / currentRate) * 100;
+
+                    if (distancePercent > 0) {
+                        if (!this.stopLossData[instrumentId]) {
+                            this.stopLossData[instrumentId] = {};
+                        }
+                        if (!this.stopLossData[instrumentId][leverage]) {
+                            this.stopLossData[instrumentId][leverage] = { distance_sum_percent: 0, count: 0 };
+                        }
+                        this.stopLossData[instrumentId][leverage].distance_sum_percent += distancePercent;
+                        this.stopLossData[instrumentId][leverage].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();
+            result[ticker] = {};
+            for (const leverage in this.stopLossData[instrumentId]) {
+                const data = this.stopLossData[instrumentId][leverage];
+                // REFACTOR: Perform final calculation directly.
+                if (data.count > 0) {
+                    result[ticker][leverage] = {
+                        average_distance_percent: data.distance_sum_percent / data.count,
+                        count: data.count
+                    };
+                }
+            }
+        }
+        return result;
+    }
+
+    reset() {
+        this.stopLossData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = DistanceToStopLossPerLeverage;

package/calculations/speculators/distance_to_tp_per_leverage.js

@@ -0,0 +1,76 @@
+/**
+ * @fileoverview Calculates the average distance to the take profit from the current price for
+ * both long and short positions, grouped by asset and leverage level.
+ * It ignores positions where take profit is not set.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class DistanceToTakeProfitPerLeverage {
+    constructor() {
+        this.takeProfitData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, userId) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            for (const position of portfolioData.PublicPositions) {
+                const instrumentId = position.InstrumentID;
+                const leverage = position.Leverage;
+                const takeProfitRate = position.TakeProfitRate;
+                const currentRate = position.CurrentRate;
+                const isBuy = position.IsBuy;
+
+                if (takeProfitRate > 0.0001 && currentRate > 0) {
+                    let distance;
+                    if (isBuy) {
+                        distance = takeProfitRate - currentRate;
+                    } else {
+                        distance = currentRate - takeProfitRate;
+                    }
+
+                    const distancePercent = (distance / currentRate) * 100;
+
+                    if (distancePercent > 0) {
+                        if (!this.takeProfitData[instrumentId]) {
+                            this.takeProfitData[instrumentId] = {};
+                        }
+                        if (!this.takeProfitData[instrumentId][leverage]) {
+                            this.takeProfitData[instrumentId][leverage] = { distance_sum_percent: 0, count: 0 };
+                        }
+                        this.takeProfitData[instrumentId][leverage].distance_sum_percent += distancePercent;
+                        this.takeProfitData[instrumentId][leverage].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();
+            result[ticker] = {};
+            for (const leverage in this.takeProfitData[instrumentId]) {
+                const data = this.takeProfitData[instrumentId][leverage];
+                // REFACTOR: Perform final calculation directly.
+                if (data.count > 0) {
+                    result[ticker][leverage] = {
+                        average_distance_percent: data.distance_sum_percent / data.count,
+                        count: data.count
+                    };
+                }
+            }
+        }
+        return result;
+    }
+
+    reset() {
+        this.takeProfitData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = DistanceToTakeProfitPerLeverage;

package/calculations/speculators/entry_distance_to_sl_per_leverage.js

@@ -0,0 +1,78 @@
+/**
+ * @fileoverview Calculates the average percentage distance from the entry price (OpenRate)
+ * to the stop loss rate for both long and short positions, grouped by asset and leverage level.
+ * It ignores near-zero stop loss values, which signify no stop loss is set.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class EntryDistanceToStopLossPerLeverage {
+    constructor() {
+        this.stopLossData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, userId) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            for (const position of portfolioData.PublicPositions) {
+                const instrumentId = position.InstrumentID;
+                const leverage = position.Leverage;
+                const stopLossRate = position.StopLossRate;
+                const openRate = position.OpenRate;
+                const isBuy = position.IsBuy;
+
+                if (stopLossRate > 0.0001 && openRate > 0) {
+                    let distance;
+                    
+                    if (isBuy) {
+                        distance = openRate - stopLossRate;
+                    } else {
+                        distance = stopLossRate - openRate;
+                    }
+
+                    const distancePercent = (distance / openRate) * 100;
+
+                    if (distancePercent > 0) {
+                        if (!this.stopLossData[instrumentId]) {
+                            this.stopLossData[instrumentId] = {};
+                        }
+                        if (!this.stopLossData[instrumentId][leverage]) {
+                            this.stopLossData[instrumentId][leverage] = { distance_sum_percent: 0, count: 0 };
+                        }
+                        this.stopLossData[instrumentId][leverage].distance_sum_percent += distancePercent;
+                        this.stopLossData[instrumentId][leverage].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();
+            result[ticker] = {};
+            for (const leverage in this.stopLossData[instrumentId]) {
+                const data = this.stopLossData[instrumentId][leverage];
+                // REFACTOR: Perform final calculation directly.
+                if (data.count > 0) {
+                    result[ticker][leverage] = {
+                        average_distance_percent: data.distance_sum_percent / data.count,
+                        count: data.count
+                    };
+                }
+            }
+        }
+        return result;
+    }
+
+    reset() {
+        this.stopLossData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = EntryDistanceToStopLossPerLeverage;

package/calculations/speculators/entry_distance_to_tp_per_leverage.js

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview Calculates the average percentage distance from the entry price (OpenRate)
+ * to the take profit rate for both long and short positions, grouped by asset and leverage level.
+ * It ignores positions where the take profit is not meaningfully set.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class EntryDistanceToTakeProfitPerLeverage {
+    constructor() {
+        this.takeProfitData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, userId) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            for (const position of portfolioData.PublicPositions) {
+                const instrumentId = position.InstrumentID;
+                const leverage = position.Leverage;
+                const takeProfitRate = position.TakeProfitRate;
+                const openRate = position.OpenRate;
+                const isBuy = position.IsBuy;
+
+                if (takeProfitRate > 0.0001 && openRate > 0) {
+                    let distance;
+                    
+                    if (isBuy) {
+                        distance = takeProfitRate - openRate;
+                    } else {
+                        distance = openRate - takeProfitRate;
+                    }
+
+                    const distancePercent = (distance / openRate) * 100;
+
+                    if (distancePercent > 0) {
+                        if (!this.takeProfitData[instrumentId]) {
+                            this.takeProfitData[instrumentId] = {};
+                        }
+                        if (!this.takeProfitData[instrumentId][leverage]) {
+                            this.takeProfitData[instrumentId][leverage] = { distance_sum_percent: 0, count: 0 };
+                        }
+                        this.takeProfitData[instrumentId][leverage].distance_sum_percent += distancePercent;
+                        this.takeProfitData[instrumentId][leverage].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();
+            result[ticker] = {};
+            for (const leverage in this.takeProfitData[instrumentId]) {
+                const data = this.takeProfitData[instrumentId][leverage];
+                // REFACTOR: Perform final calculation directly.
+                if (data.count > 0) {
+                    result[ticker][leverage] = {
+                        average_distance_percent: data.distance_sum_percent / data.count,
+                        count: data.count
+                    };
+                }
+            }
+        }
+        return result;
+    }
+
+    reset() {
+        this.takeProfitData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = EntryDistanceToTakeProfitPerLeverage;

package/calculations/speculators/holding_duration_per_asset.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Calculates the average holding duration of open speculator positions.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class HoldingDurationPerAsset {
+    constructor() {
+        this.durationData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, userId, context) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            const now = new Date();
+            for (const position of portfolioData.PublicPositions) {
+                const instrumentId = position.InstrumentID;
+                const openTime = new Date(position.OpenDateTime);
+                const durationHours = (now - openTime) / (1000 * 60 * 60);
+
+                if (!this.durationData[instrumentId]) {
+                    this.durationData[instrumentId] = { duration_sum_hours: 0, count: 0 };
+                }
+                this.durationData[instrumentId].duration_sum_hours += durationHours;
+                this.durationData[instrumentId].count++;
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.durationData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            const data = this.durationData[instrumentId];
+
+            // REFACTOR: Perform the final calculation directly.
+            if (data.count > 0) {
+                result[ticker] = {
+                    average_duration_hours: data.duration_sum_hours / data.count
+                };
+            }
+        }
+        
+        return result;
+    }
+
+    reset() {
+        this.durationData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = HoldingDurationPerAsset;