aiden-shared-calculations-unified 1.0.8 → 1.0.10

package/calculations/speculators/distance_to_stop_loss_per_leverage.js

@@ -1,78 +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;
+/**
+ * @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, yesterdayPortfolio, userId, context) {
+        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

@@ -1,76 +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;
+/**
+ * @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, yesterdayPortfolio, userId, context) {
+        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

@@ -1,78 +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;
+/**
+ * @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, yesterdayPortfolio, userId, context) {
+        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

@@ -1,77 +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;
+/**
+ * @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, yesterdayPortfolio, userId, context) {
+        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;