aiden-shared-calculations-unified 1.0.7 → 1.0.9

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;

package/calculations/speculators/holding_duration_per_asset.js

@@ -1,55 +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;
+/**
+ * @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, yesterdayPortfolio, 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;

package/calculations/speculators/leverage_per_asset.js

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

@@ -1,45 +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 = [];
-    }
-}
-
+const { getInstrumentSectorMap } = require('../../utils/sector_mapping_provider');
+
+/**
+ * @fileoverview Calculates leverage usage per sector for speculators.
+ */
+
+class LeveragePerSector {
+    constructor() {
+        this.positions = [];
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        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;