aiden-shared-calculations-unified 1.0.22 → 1.0.24

package/calculations/activity/historical/activity_by_pnl_status.js

@@ -0,0 +1,86 @@
+/**
+ * @fileoverview Analyzes *why* users were active by checking the P&L status
+ * of positions just before they were closed.
+ * This measures "Profit Taking" vs. "Capitulation".
+ */
+class ActivityByPnlStatus {
+    constructor() {
+        this.total_positions_yesterday = {
+            in_profit: 0,
+            in_loss: 0
+        };
+        this.closed_positions_today = {
+            profit_taken: 0,
+            loss_realized: 0
+        };
+    }
+
+    _getPortfolioMap(portfolio) {
+        // We MUST use PositionID here to track specific trades, not just the asset
+        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
+        if (!positions || !Array.isArray(positions)) {
+            return new Map();
+        }
+        // Map<PositionID, NetProfit>
+        return new Map(positions.map(p => [p.PositionID, p.NetProfit || 0]));
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        if (!todayPortfolio || !yesterdayPortfolio) {
+            return;
+        }
+
+        const yPosMap = this._getPortfolioMap(yesterdayPortfolio);
+        const tPosMap = this._getPortfolioMap(todayPortfolio);
+
+        if (yPosMap.size === 0) {
+            return; // No positions yesterday to analyze
+        }
+
+        for (const [yPosId, yNetProfit] of yPosMap.entries()) {
+            // 1. Bucket yesterday's P&L state
+            if (yNetProfit > 0) {
+                this.total_positions_yesterday.in_profit++;
+            } else if (yNetProfit < 0) {
+                this.total_positions_yesterday.in_loss++;
+            }
+
+            // 2. Check if this position was closed
+            if (!tPosMap.has(yPosId)) {
+                // Position was closed. Check its P&L from yesterday.
+                if (yNetProfit > 0) {
+                    this.closed_positions_today.profit_taken++;
+                } else if (yNetProfit < 0) {
+                    this.closed_positions_today.loss_realized++;
+                }
+            }
+        }
+    }
+
+    getResult() {
+        const { in_profit, in_loss } = this.total_positions_yesterday;
+        const { profit_taken, loss_realized } = this.closed_positions_today;
+
+        // Calculate rates to normalize the data
+        const profit_taking_rate = (in_profit > 0) ? (profit_taken / in_profit) * 100 : 0;
+        const capitulation_rate = (in_loss > 0) ? (loss_realized / in_loss) * 100 : 0;
+
+        return {
+            profit_taking_rate_pct: profit_taking_rate, // % of profitable positions that were closed
+            capitulation_rate_pct: capitulation_rate,   // % of losing positions that were closed
+            raw_counts: {
+                profit_positions_closed: profit_taken,
+                loss_positions_closed: loss_realized,
+                total_profit_positions_available: in_profit,
+                total_loss_positions_available: in_loss
+            }
+        };
+    }
+
+    reset() {
+        this.total_positions_yesterday = { in_profit: 0, in_loss: 0 };
+        this.closed_positions_today = { profit_taken: 0, loss_realized: 0 };
+    }
+}
+
+module.exports = ActivityByPnlStatus;

package/calculations/activity/historical/daily_asset_activity.js

@@ -0,0 +1,86 @@
+/**
+ * @fileoverview Tracks the flow of unique users opening or closing positions
+ * on a per-asset basis. This measures the "focus" of the crowd's activity.
+ */
+const { loadInstrumentMappings } = require('../../../utils/sector_mapping_provider');
+
+class DailyAssetActivity {
+    constructor() {
+        // We will store { [instrumentId]: { new_users: Set(), closed_users: Set() } }
+        this.assetActivity = new Map();
+        this.mappings = null;
+    }
+
+    _initAsset(instrumentId) {
+        if (!this.assetActivity.has(instrumentId)) {
+            this.assetActivity.set(instrumentId, {
+                new_users: new Set(),
+                closed_users: new Set()
+            });
+        }
+    }
+
+    _getInstrumentIds(portfolio) {
+        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
+        if (!positions || !Array.isArray(positions)) {
+            return new Set();
+        }
+        return new Set(positions.map(p => p.InstrumentID).filter(Boolean));
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        if (!todayPortfolio || !yesterdayPortfolio) {
+            return;
+        }
+
+        const yIds = this._getInstrumentIds(yesterdayPortfolio);
+        const tIds = this._getInstrumentIds(todayPortfolio);
+
+        // Find new positions (in today but not yesterday)
+        for (const tId of tIds) {
+            if (!yIds.has(tId)) {
+                this._initAsset(tId);
+                this.assetActivity.get(tId).new_users.add(userId);
+            }
+        }
+
+        // Find closed positions (in yesterday but not today)
+        for (const yId of yIds) {
+            if (!tIds.has(yId)) {
+                this._initAsset(yId);
+                this.assetActivity.get(yId).closed_users.add(userId);
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+
+        const result = {};
+        for (const [instrumentId, data] of this.assetActivity.entries()) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            
+            const openCount = data.new_users.size;
+            const closeCount = data.closed_users.size;
+            
+            if (openCount > 0 || closeCount > 0) {
+                result[ticker] = {
+                    opened_by_user_count: openCount,
+                    closed_by_user_count: closeCount,
+                    // "Net User Flow" - positive means more users joined than left
+                    net_user_flow: openCount - closeCount 
+                };
+            }
+        }
+        return result;
+    }
+
+    reset() {
+        this.assetActivity.clear();
+        this.mappings = null;
+    }
+}
+
+module.exports = DailyAssetActivity;

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/activity/historical/speculator_adjustment_activity.js

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview Tracks "tinkering" activity from speculators.
+ * Instead of just opening/closing, this counts how many users
+ * actively *adjusted* the SL, TP, or TSL on existing trades.
+ */
+class SpeculatorAdjustmentActivity {
+    constructor() {
+        // Use Sets to count unique users
+        this.sl_adjusted_users = new Set();
+        this.tp_adjusted_users = new Set();
+        this.tsl_toggled_users = new Set();
+    }
+
+    _getPublicPositionsMap(portfolio) {
+        const positions = portfolio?.PublicPositions;
+        if (!positions || !Array.isArray(positions)) {
+            return new Map();
+        }
+        // Map<PositionID, PositionObject>
+        return new Map(positions.map(p => [p.PositionID, p]));
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        // This calculation is only for speculators
+        if (todayPortfolio?.context?.userType !== 'speculator' || !yesterdayPortfolio) {
+            return;
+        }
+
+        const yPosMap = this._getPublicPositionsMap(yesterdayPortfolio);
+        const tPosMap = this._getPublicPositionsMap(todayPortfolio);
+
+        if (yPosMap.size === 0 || tPosMap.size === 0) {
+            return; // No positions to compare
+        }
+
+        for (const [tPosId, tPos] of tPosMap.entries()) {
+            // Check if this position existed yesterday
+            if (yPosMap.has(tPosId)) {
+                const yPos = yPosMap.get(tPosId);
+
+                // 1. Check for Stop Loss adjustment
+                if (tPos.StopLossRate !== yPos.StopLossRate) {
+                    this.sl_adjusted_users.add(userId);
+                }
+
+                // 2. Check for Take Profit adjustment
+                if (tPos.TakeProfitRate !== yPos.TakeProfitRate) {
+                    this.tp_adjusted_users.add(userId);
+                }
+                
+                // 3. Check if TSL was toggled on or off
+                if (tPos.IsTslEnabled !== yPos.IsTslEnabled) {
+                    this.tsl_toggled_users.add(userId);
+                }
+            }
+        }
+    }
+
+    getResult() {
+        return {
+            // Count of unique users who adjusted at least one trade's SL
+            unique_users_adjusted_sl: this.sl_adjusted_users.size,
+            // Count of unique users who adjusted at least one trade's TP
+            unique_users_adjusted_tp: this.tp_adjusted_users.size,
+            // Count of unique users who toggled TSL on or off
+            unique_users_toggled_tsl: this.tsl_toggled_users.size
+        };
+    }
+
+    reset() {
+        this.sl_adjusted_users.clear();
+        this.tp_adjusted_users.clear();
+        this.tsl_toggled_users.clear();
+    }
+}
+
+module.exports = SpeculatorAdjustmentActivity;

package/package.json

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