aiden-shared-calculations-unified 1.0.95 → 1.0.97

package/calculations/legacy/daily_asset_activity.js

@@ -1,128 +0,0 @@
-/**
- * @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;
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": "object",
-            "description": "Tracks the net flow of unique users opening or closing positions per asset.",
-            "patternProperties": {
-                // This matches any string key (which will be a ticker)
-                "^.*$": {
-                    "type": "object",
-                    "description": "User flow metrics for a specific asset ticker.",
-                    "properties": {
-                        "opened_by_user_count": {
-                            "type": "number",
-                            "description": "Count of unique users who opened a position in this asset."
-                        },
-                        "closed_by_user_count": {
-                            "type": "number",
-                            "description": "Count of unique users who closed their position in this asset."
-                        },
-                        "net_user_flow": {
-                            "type": "number",
-                            "description": "Net change in users (opened - closed)."
-                        }
-                    },
-                    "required": ["opened_by_user_count", "closed_by_user_count", "net_user_flow"]
-                }
-            },
-            // Use 'additionalProperties' as a fallback for patternProperties
-            "additionalProperties": {
-                "type": "object",
-                "properties": {
-                    "opened_by_user_count": { "type": "number" },
-                    "closed_by_user_count": { "type": "number" },
-                    "net_user_flow": { "type": "number" }
-                }
-            }
-        };
-    }
-
-    _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/legacy/daily_user_activity_tracker.js

@@ -1,182 +0,0 @@
-/**
- * @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
-        };
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": "object",
-            "description": "Tracks the count of daily active users based on portfolio changes.",
-            "properties": {
-                "rawActiveUserCount": {
-                    "type": "number",
-                    "description": "The total count of unique users who were active today (opened, closed, or reallocated)."
-                },
-                "activityBreakdown": {
-                    "type": "object",
-                    "description": "A breakdown of the first activity event type recorded for active users.",
-                    "properties": {
-                        "new_position": {
-                            "type": "number",
-                            "description": "Count of users whose first detected activity was opening a new position."
-                        },
-                        "closed_position": {
-                            "type": "number",
-                            "description": "Count of users whose first detected activity was closing an existing position."
-                        },
-                        "reallocation": {
-                            "type": "number",
-                            "description": "Count of users whose first detected activity was reallocating an existing position."
-                        }
-                    },
-                    "required": ["new_position", "closed_position", "reallocation"]
-                }
-            },
-            "required": ["rawActiveUserCount", "activityBreakdown"]
-        };
-    }
-
-    /**
-     * 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
-        // 3. Check for reallocation (only possible if we have AggregatedPositions for both days)
-        if (yHasAgg && tHasAgg) {
-            for (const tId of tIds) {
-                const tInvested = tPosMap.get(tId).invested;
-                const yInvested = yPosMap.get(tId)?.invested ?? 0;
-
-                // 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;
-                }
-            }
-        }
-
-
-        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/legacy/deposit_withdrawal_percentage.js

@@ -1,125 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 2) for deposit/withdrawal percentage.
- *
- * This metric estimates the net cash flow (deposits vs. withdrawals)
- * by analyzing changes in portfolio percentages.
- *
- * It's a proxy based on the assumption that changes in the *sum* of
- * position percentages not accounted for by P&L represent new cash.
- *
- * (DEPRECIATED by crowd-cash-flow-proxy, but kept for reference)
- */
-class DepositWithdrawalPercentage {
-    constructor() {
-        this.invested_pct_yesterday_sum = 0;
-        this.invested_pct_today_sum = 0;
-        this.pnl_pct_today_sum = 0;
-        this.user_count = 0;
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": "object",
-            "description": "(DEPRECIATED) Estimates net cash flow by analyzing changes in portfolio position percentages.",
-            "properties": {
-                "estimated_net_flow_pct": {
-                    "type": "number",
-                    "description": "The estimated net cash flow (deposit/withdrawal) as an average percentage change across all users."
-                },
-                "user_count": {
-                    "type": "number",
-                    "description": "Number of users processed."
-                },
-                "debug": {
-                    "type": "object",
-                    "properties": {
-                        "invested_pct_yesterday_sum": { "type": "number" },
-                        "invested_pct_today_sum": { "type": "number" },
-                        "pnl_pct_today_sum": { "type": "number" }
-                    }
-                }
-            },
-            "required": ["estimated_net_flow_pct", "user_count"]
-        };
-    }
-
-    _getPortfolioSums(portfolio) {
-        const positions = portfolio?.AggregatedPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return { investedPct: 0, pnlPct: 0 };
-        }
-        
-        let investedPct = 0;
-        let pnlPct = 0;
-        
-        for (const pos of positions) {
-            investedPct += pos.InvestedAmount || pos.Invested || 0;
-            pnlPct += (pos.NetProfit || 0) / 100; // Assuming NetProfit is in %
-        }
-        
-        return { investedPct, pnlPct };
-    }
-
-    process(todayPortfolio, yesterdayPortfolio) {
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
-
-        const ySums = this._getPortfolioSums(yesterdayPortfolio);
-        const tSums = this._getPortfolioSums(todayPortfolio);
-        
-        if (ySums.investedPct === 0 && tSums.investedPct === 0) {
-            return; // Skip users with no positions
-        }
-
-        this.invested_pct_yesterday_sum += ySums.investedPct;
-        this.invested_pct_today_sum += tSums.investedPct;
-        this.pnl_pct_today_sum += tSums.pnlPct; // Use today's P&L
-        this.user_count++;
-    }
-
-    getResult() {
-        if (this.user_count === 0) {
-            return { 
-                estimated_net_flow_pct: 0, 
-                user_count: 0,
-                debug: {
-                    invested_pct_yesterday_sum: 0,
-                    invested_pct_today_sum: 0,
-                    pnl_pct_today_sum: 0
-                }
-            };
-        }
-        
-        // Avg % change in invested capital
-        const avg_invested_change = (this.invested_pct_today_sum - this.invested_pct_yesterday_sum) / this.user_count;
-        // Avg P&L
-        const avg_pnl = this.pnl_pct_today_sum / this.user_count;
-
-        // The change not accounted for by P&L is the proxy flow
-        const net_flow_pct = avg_invested_change - avg_pnl;
-
-        return {
-            estimated_net_flow_pct: net_flow_pct,
-            user_count: this.user_count,
-            debug: {
-                invested_pct_yesterday_sum: this.invested_pct_yesterday_sum,
-                invested_pct_today_sum: this.invested_pct_today_sum,
-                pnl_pct_today_sum: this.pnl_pct_today_sum
-            }
-        };
-    }
-
-    reset() {
-        this.invested_pct_yesterday_sum = 0;
-        this.invested_pct_today_sum = 0;
-        this.pnl_pct_today_sum = 0;
-        this.user_count = 0;
-    }
-}
-
-module.exports = DepositWithdrawalPercentage;

package/calculations/legacy/diversification_pnl.js

@@ -1,115 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 1) for Diversification vs. P&L.
- *
- * This metric answers: "Is there a correlation between the number
- * of sectors a user is invested in and their average P&L?"
- *
- * REFACTOR: This calculation now aggregates the results on the server,
- * returning the average P&L per score, not raw data arrays.
- */
-class DiversificationPnl {
-    constructor() {
-        // Stores { [score]: { pnlSum: 0, count: 0 } }
-        // The 'score' is the number of unique sectors
-        this.pnlByScore = new Map();
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * REFACTOR: Schema now describes the final aggregated result.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        const scoreSchema = {
-            "type": "object",
-            "description": "Aggregated P&L data for a specific diversification score.",
-            "properties": {
-                "average_pnl": {
-                    "type": "number",
-                    "description": "The average P&L (in USD) for all users with this score."
-                },
-                "user_count": {
-                    "type": "number",
-                    "description": "The number of users who had this diversification score."
-                }
-            },
-            "required": ["average_pnl", "user_count"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Calculates the average P&L correlated by diversification score (number of unique sectors).",
-            "patternProperties": {
-                "^[0-9]+$": scoreSchema // Key is the score (e.g., "1", "2")
-            },
-            "additionalProperties": scoreSchema
-        };
-    }
-
-    _initScore(score) {
-        if (!this.pnlByScore.has(score)) {
-            this.pnlByScore.set(score, { pnlSum: 0, count: 0 });
-        }
-    }
-
-    /**
-     * @param {object} todayPortfolio
-     * @param {object} yesterdayPortfolio
-     */
-    process(todayPortfolio, yesterdayPortfolio) {
-        const tPositions = todayPortfolio.PublicPositions || todayPortfolio.AggregatedPositions;
-        if (!tPositions || !Array.isArray(tPositions) || tPositions.length === 0) {
-            return;
-        }
-
-        const yPortfolio = yesterdayPortfolio.Portfolio;
-        if (!yPortfolio) return;
-
-        // 1. Calculate diversification score (count of unique sectors)
-        const sectors = new Set();
-        for (const pos of tPositions) {
-            if (pos.SectorID) {
-                sectors.add(pos.SectorID);
-            }
-        }
-        const diversificationScore = sectors.size;
-
-        // Skip users with 0 positions/sectors
-        if (diversificationScore === 0) {
-            return;
-        }
-        
-        // 2. Get total P&L from yesterday's snapshot
-        const pnl = yPortfolio.Equity - yPortfolio.EquityBase; // Total P&L in USD
-
-        // 3. Store P&L sum and count by score
-        this._initScore(diversificationScore);
-        const data = this.pnlByScore.get(diversificationScore);
-        data.pnlSum += pnl;
-        data.count++;
-    }
-
-    /**
-     * REFACTOR: This method now calculates the final average P&L per score.
-     */
-    getResult() {
-        const result = {};
-
-        for (const [score, data] of this.pnlByScore.entries()) {
-            if (data.count > 0) {
-                result[score] = {
-                    average_pnl: data.pnlSum / data.count,
-                    user_count: data.count
-                };
-            }
-        }
-        
-        return result;
-    }
-
-    reset() {
-        this.pnlByScore.clear();
-    }
-}
-
-module.exports = DiversificationPnl;

package/calculations/legacy/drawdown_response.js

@@ -1,137 +0,0 @@
-/**
- * @fileoverview Calculation (Pass 2) for drawdown response.
- *
- * This metric answers: "How do users behave when a position has a
- * drawdown of over 10%?"
- *
- * It checks all positions from yesterday that were in >10% loss
- * and tracks whether the user:
- * 1. Held (position still open today, same size)
- * 2. Closed (position no longer open today)
- * 3. Added (position still open, but Invested % is larger)
- */
-class DrawdownResponse {
-    constructor() {
-        this.actions = {
-            held: 0,
-            closed: 0,
-            added: 0
-        };
-        this.total_in_drawdown = 0;
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        return {
-            "type": "object",
-            "description": "Analyzes user behavior in response to a >10% position drawdown.",
-            "properties": {
-                "total_positions_in_drawdown": {
-                    "type": "number",
-                    "description": "Total positions from yesterday that were in >10% drawdown."
-                },
-                "action_held_pct": {
-                    "type": "number",
-                    "description": "Percentage of drawdown positions that were held."
-                },
-                "action_closed_pct": {
-                    "type": "number",
-                    "description": "Percentage of drawdown positions that were closed."
-                },
-                "action_added_pct": {
-                    "type": "number",
-                    "description": "Percentage of drawdown positions that were added to."
-                },
-                "raw_counts": {
-                    "type": "object",
-                    "properties": {
-                        "held": { "type": "number" },
-                        "closed": { "type": "number" },
-                        "added": { "type": "number" }
-                    },
-                    "required": ["held", "closed", "added"]
-                }
-            },
-            "required": ["total_positions_in_drawdown", "action_held_pct", "action_closed_pct", "action_added_pct", "raw_counts"]
-        };
-    }
-
-    _getPortfolioMap(portfolio) {
-        // We MUST use PositionID to track specific trades
-        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return new Map();
-        }
-        // Map<PositionID, { pnl: number, invested: number }>
-        return new Map(positions.map(p => [p.PositionID, {
-            pnl: (p.NetProfit || 0) / (p.InvestedAmount || p.Amount || 1), // PNL as %
-            invested: p.InvestedAmount || p.Amount || 0
-        }]));
-    }
-
-    process(todayPortfolio, yesterdayPortfolio) {
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
-
-        const yPosMap = this._getPortfolioMap(yesterdayPortfolio);
-        const tPosMap = this._getPortfolioMap(todayPortfolio);
-
-        if (yPosMap.size === 0) {
-            return;
-        }
-
-        for (const [yPosId, yPosData] of yPosMap.entries()) {
-            // Check if position was in >10% drawdown
-            if (yPosData.pnl < -0.10) {
-                this.total_in_drawdown++;
-
-                // Now, check what happened today
-                if (!tPosMap.has(yPosId)) {
-                    // 1. Position was closed
-                    this.actions.closed++;
-                } else {
-                    const tPosData = tPosMap.get(yPosId);
-                    // 2. Position was added to (check for > 1% increase to avoid noise)
-                    if (tPosData.invested > (yPosData.invested * 1.01)) {
-                        this.actions.added++;
-                    } else {
-                        // 3. Position was held
-                        this.actions.held++;
-                    }
-                }
-            }
-        }
-    }
-
-    getResult() {
-        const total = this.total_in_drawdown;
-        if (total === 0) {
-            return {
-                total_positions_in_drawdown: 0,
-                action_held_pct: 0,
-                action_closed_pct: 0,
-                action_added_pct: 0,
-                raw_counts: this.actions
-            };
-        }
-
-        return {
-            total_positions_in_drawdown: total,
-            action_held_pct: (this.actions.held / total) * 100,
-            action_closed_pct: (this.actions.closed / total) * 100,
-            action_added_pct: (this.actions.added / total) * 100,
-            raw_counts: this.actions
-        };
-    }
-
-    reset() {
-        this.actions = { held: 0, closed: 0, added: 0 };
-        this.total_in_drawdown = 0;
-    }
-}
-
-module.exports = DrawdownResponse;