aiden-shared-calculations-unified 1.0.21 → 1.0.23

package/calculations/activity/historical/daily_user_activity_tracker.js

@@ -0,0 +1,144 @@
+/**
+ * @fileoverview Tracks user activity by comparing portfolio snapshots.
+ * This is a historical calculation that defines an "active user" as someone
+ * who has opened, closed, or reallocated a position within the last 24 hours.
+ *
+ * This provides the "Daily Active Users" count for the monitored cohort.
+ * This depreciates the user activity sampler cloud function which was inefficient for the api usage and now provides this data for free
+ */
+
+class DailyUserActivityTracker {
+    constructor() {
+        this.activeUserIds = new Set();
+        this.activityEvents = {
+            new_position: 0,
+            closed_position: 0,
+            reallocation: 0
+        };
+    }
+
+    /**
+     * Helper to get a simplified map of positions for comparison.
+     * @param {object} portfolio - A user's full portfolio object.
+     * @returns {object} { posMap: Map<InstrumentID, {invested: number}>, hasAggregated: boolean }
+     */
+    _getPortfolioMaps(portfolio) {
+        // Prioritize AggregatedPositions, but fall back to PublicPositions
+        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
+        if (!positions || !Array.isArray(positions)) {
+            return { posMap: new Map(), hasAggregated: false };
+        }
+
+        const posMap = new Map();
+        for (const pos of positions) {
+            const key = pos.InstrumentID;
+            if (key) {
+                posMap.set(key, {
+                    // 'InvestedAmount' or 'Invested' is the portfolio percentage
+                    // We use this for reallocation logic.
+                    invested: pos.InvestedAmount || pos.Invested || pos.Amount || 0
+                });
+            }
+        }
+        // Return the map and a flag indicating if we can trust the 'invested' field
+        return { posMap, hasAggregated: !!portfolio.AggregatedPositions };
+    }
+
+    /**
+     * Processes a single user's daily data.
+     */
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        // This calculation requires both days to find changes.
+        if (!todayPortfolio || !yesterdayPortfolio) {
+            return;
+        }
+
+        const { posMap: yPosMap, hasAggregated: yHasAgg } = this._getPortfolioMaps(yesterdayPortfolio);
+        const { posMap: tPosMap, hasAggregated: tHasAgg } = this._getPortfolioMaps(todayPortfolio);
+
+        // Skip if user has no positions on either day
+        if (tPosMap.size === 0 && yPosMap.size === 0) {
+            return;
+        }
+
+        const yIds = new Set(yPosMap.keys());
+        const tIds = new Set(tPosMap.keys());
+        let isActive = false;
+
+        // 1. Check for new positions (high-confidence activity)
+        for (const tId of tIds) {
+            if (!yIds.has(tId)) {
+                isActive = true;
+                this.activityEvents.new_position++;
+                break; // Found activity, no need to check more
+            }
+        }
+
+        if (isActive) {
+            this.activeUserIds.add(userId);
+            return;
+        }
+
+        // 2. Check for closed positions (high-confidence activity)
+        for (const yId of yIds) {
+            if (!tIds.has(yId)) {
+                isActive = true;
+                this.activityEvents.closed_position++;
+                break; // Found activity
+            }
+        }
+
+        if (isActive) {
+            this.activeUserIds.add(userId);
+            return;
+        }
+
+        // 3. Check for reallocation (only possible if we have AggregatedPositions for both days)
+        // This checks for changes in the 'Invested' percentage
+        if (yHasAgg && tHasAgg) {
+            for (const tId of tIds) {
+                // We know tId is also in yIds from the checks above
+                const tInvested = tPosMap.get(tId).invested;
+                const yInvested = yPosMap.get(yId).invested;
+
+                // Check for a meaningful change (e.g., > 0.01% to avoid float noise)
+                if (Math.abs(tInvested - yInvested) > 0.0001) {
+                    isActive = true;
+                    this.activityEvents.reallocation++;
+                    break; // Found activity
+                }
+            }
+        }
+
+        if (isActive) {
+            this.activeUserIds.add(userId);
+        }
+    }
+
+    /**
+     * Returns the final aggregated counts for the day.
+     */
+    getResult() {
+        return {
+            // This is the main metric for your graph
+            rawActiveUserCount: this.activeUserIds.size,
+            
+            // This is a bonus metric to see *what* users are doing
+            activityBreakdown: this.activityEvents
+        };
+    }
+
+    /**
+     * Resets the counters for the next run.
+     */
+    reset() {
+        this.activeUserIds.clear();
+        this.activityEvents = {
+            new_position: 0,
+            closed_position: 0,
+            reallocation: 0
+        };
+    }
+}
+
+module.exports = DailyUserActivityTracker;

package/calculations/asset_metrics/asset_position_size.js

@@ -1,5 +1,5 @@
 /**
- * Calculates the average position size for each asset.
+ * Calculates the average position size (as a portfolio percentage) for each asset.
  */
 const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
@@ -22,7 +22,8 @@ class AssetPositionSize {
             }
 
             this.assets[instrumentId].position_count++;
-            this.assets[instrumentId].position_value_sum += (position.InvestedAmount || position.Amount || 0);
+            // FIX: Use the 'Invested' field, which holds the portfolio percentage
+            this.assets[instrumentId].position_value_sum += (position.Invested || 0);
         }
     }
 
@@ -36,11 +37,11 @@ class AssetPositionSize {
             const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
             const data = this.assets[instrumentId];
             
-            // REFACTOR: Perform final calculation and return in standardized format.
             if (data.position_count > 0) {
                 result[ticker] = {
+                    // This is now the average *percentage* size
                     average_position_size: data.position_value_sum / data.position_count,
-                    position_count: data.position_count // Also include count for context
+                    position_count: data.position_count
                 };
             }
         }
@@ -54,4 +55,4 @@ class AssetPositionSize {
     }
 }
 
-module.exports = AssetPositionSize;
+module.exports = AssetPositionSize;

package/calculations/behavioural/historical/drawdown_response.js

@@ -15,7 +15,6 @@ class DrawdownResponse {
             return; // Need both days for comparison
         }
 
-        // FIX: Get the correct positions arrays and ensure they are iterable
         const yPositions = yesterdayPortfolio.AggregatedPositions || yesterdayPortfolio.PublicPositions;
         const tPositions = todayPortfolio.AggregatedPositions || todayPortfolio.PublicPositions;
 
@@ -23,20 +22,24 @@ class DrawdownResponse {
             return;
         }
 
-        // Create a map of today's positions for efficient lookup
-        const todayPositions = new Map(tPositions.map(p => [p.PositionID, p]));
+        // Use PositionID if available (as in original file), fallback to InstrumentID
+        const todayPositions = new Map(tPositions.map(p => [p.PositionID || p.InstrumentID, p]));
 
         for (const yPos of yPositions) {
-            const drawdownPercent = yPos.InvestedAmount > 0 ? yPos.ProfitAndLoss / yPos.InvestedAmount : 0;
+            // FIX: Use the NetProfit field, which is already a percentage.
+            // Your data sample (e.g., -83.6) shows the threshold should be -10.0.
+            const drawdownPercent = yPos.NetProfit || 0;
+            const yPosId = yPos.PositionID || yPos.InstrumentID;
 
             // Check if this position was in a >10% drawdown yesterday
-            if (drawdownPercent < -0.10) {
-                const todayPos = todayPositions.get(yPos.PositionID);
+            if (drawdownPercent < -10.0) {
+                const todayPos = todayPositions.get(yPosId);
 
                 if (!todayPos) {
                     // Position was closed
                     this.drawdown_events.closed_position++;
-                } else if (todayPos.InvestedAmount > yPos.InvestedAmount) {
+                } else if (todayPos.Invested > yPos.Invested) {
+                    // FIX: Use 'Invested' (percentage) to check for increase
                     // User added money to the losing position
                     this.drawdown_events.added_to_position++;
                 } else {

package/calculations/behavioural/historical/gain_response.js

@@ -15,7 +15,6 @@ class GainResponse {
             return; // Need both days for comparison
         }
 
-        // FIX: Get the correct positions arrays and ensure they are iterable
         const yPositions = yesterdayPortfolio.AggregatedPositions || yesterdayPortfolio.PublicPositions;
         const tPositions = todayPortfolio.AggregatedPositions || todayPortfolio.PublicPositions;
 
@@ -23,19 +22,24 @@ class GainResponse {
             return;
         }
 
-        const todayPositions = new Map(tPositions.map(p => [p.PositionID, p]));
+        // Use PositionID if available (as in original file), fallback to InstrumentID
+        const todayPositions = new Map(tPositions.map(p => [p.PositionID || p.InstrumentID, p]));
 
         for (const yPos of yPositions) {
-            const gainPercent = yPos.InvestedAmount > 0 ? yPos.ProfitAndLoss / yPos.InvestedAmount : 0;
+            // FIX: Use the NetProfit field, which is already a percentage.
+            // Your data sample (e.g., 23.5) shows the threshold should be 10.0.
+            const gainPercent = yPos.NetProfit || 0;
+            const yPosId = yPos.PositionID || yPos.InstrumentID;
 
             // Check if this position was in a >10% gain yesterday
-            if (gainPercent > 0.10) {
-                const todayPos = todayPositions.get(yPos.PositionID);
+            if (gainPercent > 10.0) {
+                const todayPos = todayPositions.get(yPosId);
 
                 if (!todayPos) {
                     // Position was closed (took full profit)
                     this.gain_events.closed_position++;
-                } else if (todayPos.InvestedAmount < yPos.InvestedAmount) {
+                } else if (todayPos.Invested < yPos.Invested) {
+                    // FIX: Use 'Invested' (percentage) to check for reduction
                     // User reduced the position (took partial profit)
                     this.gain_events.reduced_position++;
                 } else {

package/calculations/behavioural/historical/position_count_pnl.js

@@ -14,15 +14,28 @@ class PositionCountPnl {
         }
     }
 
+    /**
+     * FIX: Helper function to calculate total P&L from positions
+     * @param {object} portfolio
+     * @returns {number|null}
+     */
+    _calculateTotalPnl(portfolio) {
+        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
+        if (positions && Array.isArray(positions)) {
+            // Sum all NetProfit fields, defaulting to 0 if a position has no NetProfit
+            return positions.reduce((sum, pos) => sum + (pos.NetProfit || 0), 0);
+        }
+        return null;
+    }
+
     process(todayPortfolio, yesterdayPortfolio, userId) {
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return; // Need P/L and today's data
+        // FIX: Only need todayPortfolio for this logic
+        if (!todayPortfolio) {
+            return;
         }
 
-        // FIX: Get the correct positions array
         const positions = todayPortfolio.AggregatedPositions || todayPortfolio.PublicPositions;
         
-        // FIX: Add check to ensure positions is an iterable array
         if (!positions || !Array.isArray(positions)) {
             return; // Skip users with no positions array
         }
@@ -32,7 +45,12 @@ class PositionCountPnl {
             return; // Skip users with no positions
         }
 
-        const dailyPnl = todayPortfolio.PortfolioValue - yesterdayPortfolio.PortfolioValue;
+        // FIX: Calculate dailyPnl by summing NetProfit from all positions
+        const dailyPnl = this._calculateTotalPnl(todayPortfolio);
+
+        if (dailyPnl === null) {
+            return; // Cannot calculate P&L for this user
+        }
 
         this._initBucket(positionCount);
         this.pnl_by_position_count[positionCount].pnl_sum += dailyPnl;

package/calculations/sectors/historical/diversification_pnl.js

@@ -5,11 +5,9 @@ const { getInstrumentSectorMap } = require('../../../utils/sector_mapping_provid
  * Aggregates P/L by the number of unique sectors a user is invested in.
  */
 class DiversificationPnl {
-    // ... (rest of the code is unchanged) ...
     constructor() {
         this.pnl_by_sector_count = {};
-        // Load the mapping on initialization
-        this.sectorMapping = null; // Changed: Load async in process
+        this.sectorMapping = null;
     }
 
     _initBucket(count) {
@@ -18,11 +16,26 @@ class DiversificationPnl {
         }
     }
 
+    /**
+     * FIX: Helper function to calculate total P&L from positions
+     * @param {object} portfolio
+     * @returns {number|null}
+     */
+    _calculateTotalPnl(portfolio) {
+        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
+        if (positions && Array.isArray(positions)) {
+            // Sum all NetProfit fields, defaulting to 0 if a position has no NetProfit
+            return positions.reduce((sum, pos) => sum + (pos.NetProfit || 0), 0);
+        }
+        return null;
+    }
+
     async process(todayPortfolio, yesterdayPortfolio, userId) { // Added async
-        if (!yesterdayPortfolio || !todayPortfolio) {
+        // FIX: Only need todayPortfolio for this logic
+        if (!todayPortfolio) {
             return;
         }
-         // Load mapping if not already loaded
+         
         if(!this.sectorMapping) {
             this.sectorMapping = await getInstrumentSectorMap();
         }
@@ -44,7 +57,12 @@ class DiversificationPnl {
             return;
         }
 
-        const dailyPnl = todayPortfolio.PortfolioValue - yesterdayPortfolio.PortfolioValue;
+        // FIX: Calculate dailyPnl by summing NetProfit from all positions
+        const dailyPnl = this._calculateTotalPnl(todayPortfolio);
+
+        if (dailyPnl === null) {
+            return; // Cannot calculate P&L for this user
+        }
 
         this._initBucket(sectorCount);
         this.pnl_by_sector_count[sectorCount].pnl_sum += dailyPnl;

package/calculations/speculators/historical/tsl_effectiveness.js

@@ -8,21 +8,41 @@ class TslEffectiveness {
         this.nontsl_group = { pnl_sum: 0, count: 0 };
     }
 
+    /**
+     * FIX: Helper function to calculate total P&L from positions
+     * @param {object} portfolio
+     * @returns {number|null}
+     */
+    _calculateTotalPnl(portfolio) {
+        // Speculators use PublicPositions
+        const positions = portfolio?.PublicPositions;
+        if (positions && Array.isArray(positions)) {
+            // Sum all NetProfit fields, defaulting to 0 if a position has no NetProfit
+            return positions.reduce((sum, pos) => sum + (pos.NetProfit || 0), 0);
+        }
+        return null;
+    }
+
     process(todayPortfolio, yesterdayPortfolio, userId) {
-        // Check if user is a speculator and we have both days' data
-        if (todayPortfolio?.context?.userType !== 'speculator' || !yesterdayPortfolio) {
+        // Check if user is a speculator and we have today's data
+        // FIX: yesterdayPortfolio is not needed for this logic, only today's P&L
+        if (todayPortfolio?.context?.userType !== 'speculator' || !todayPortfolio) {
             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;
+        // FIX: Calculate dailyPnl by summing NetProfit from all positions
+        const dailyPnl = this._calculateTotalPnl(todayPortfolio);
+
+        if (dailyPnl === null) {
+            return; // Cannot calculate P&L
+        }
+        
         const usesTSL = positions.some(p => p.IsTslEnabled);
 
         if (usesTSL) {

package/package.json

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

package/calculations/asset_metrics/asset_dollar_metrics.js

@@ -1,51 +0,0 @@
-/**
- * Aggregates the total dollar amount invested in assets,
- * broken down by profit or loss (from our sample).
- */
-class AssetDollarMetrics {
-    constructor() {
-        this.assets = {};
-    }
-
-    _initAsset(ticker) {
-        if (!this.assets[ticker]) {
-            this.assets[ticker] = {
-                total_invested_sum: 0,
-                profit_invested_sum: 0,
-                loss_invested_sum: 0
-            };
-        }
-    }
-
-    process(portfolioData, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights) {
-        const { instrumentMappings } = context;
-
-        // FIX: Use the correct portfolio position properties
-        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
-        if (!positions || !Array.isArray(positions)) return;
-
-        for (const position of positions) {
-            // FIX: Use the correct PascalCase InstrumentID
-            const ticker = instrumentMappings[position.InstrumentID];
-            if (!ticker) continue;
-
-            this._initAsset(ticker);
-
-            // FIX: Use the correct PascalCase InvestedAmount
-            this.assets[ticker].total_invested_sum += position.InvestedAmount;
-
-            // FIX: Use the correct PascalCase NetProfit
-            if (position.NetProfit > 0) {
-                this.assets[ticker].profit_invested_sum += position.InvestedAmount;
-            } else {
-                this.assets[ticker].loss_invested_sum += position.InvestedAmount;
-            }
-        }
-    }
-
-    getResult() {
-        return this.assets;
-    }
-}
-
-module.exports = AssetDollarMetrics;

package/calculations/sectors/sector_dollar_metrics.js

@@ -1,49 +0,0 @@
-/**
- * Aggregates the total dollar amount invested in sectors,
- * broken down by profit or loss (from our sample).
- */
-class SectorDollarMetrics {
-    constructor() {
-        this.sectors = {};
-    }
-
-    _initSector(sector) {
-        if (!this.sectors[sector]) {
-            this.sectors[sector] = {
-                total_invested_sum: 0,
-                profit_invested_sum: 0,
-                loss_invested_sum: 0
-            };
-        }
-    }
-
-    process(portfolioData, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights) {
-        const { sectorMapping } = context; // Assumes sectorMapping is in context
-
-        // FIX: Use the correct portfolio position properties
-        const positions = portfolioData.AggregatedPositions || portfolioData.PublicPositions;
-        if (!positions || !Array.isArray(positions)) return;
-
-        for (const position of positions) {
-            // FIX: Use the correct PascalCase InstrumentID
-            const sector = sectorMapping[position.InstrumentID] || 'Other';
-            this._initSector(sector);
-
-            // FIX: Use the correct PascalCase InvestedAmount
-            this.sectors[sector].total_invested_sum += position.InvestedAmount;
-
-            // FIX: Use the correct PascalCase NetProfit
-            if (position.NetProfit > 0) {
-                this.sectors[sector].profit_invested_sum += position.InvestedAmount;
-            } else {
-                this.sectors[sector].loss_invested_sum += position.InvestedAmount;
-            }
-        }
-    }
-
-    getResult() {
-        return this.sectors;
-    }
-}
-
-module.exports = SectorDollarMetrics;