aiden-shared-calculations-unified 1.0.113 → 1.0.115

package/calculations/popular-investor/AggregateAssetAUM.js

@@ -0,0 +1,66 @@
+/**
+ * @fileoverview Aggregate AUM per Asset Across All Users.
+ * Returns the AUM invested into each asset total across all users.
+ */
+
+class AggregateAssetAUM {
+    constructor() {
+        this.results = {};
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            category: 'popular_investor_meta'
+        };
+    }
+
+    static getDependencies() { return ['UserAUMPerAsset']; }
+
+    static getSchema() {
+        return {
+            type: 'object',
+            additionalProperties: { type: 'number' },
+            description: 'Map of instrumentId -> total AUM across all users'
+        };
+    }
+
+    process(context) {
+        const aumPerAssetData = context.computed['UserAUMPerAsset'];
+
+        if (!aumPerAssetData) {
+            this.results['meta'] = {};
+            return;
+        }
+
+        // Aggregate AUM per instrument across all users
+        const instrumentAUM = new Map();
+
+        for (const [userId, userAssets] of Object.entries(aumPerAssetData)) {
+            if (!userAssets || typeof userAssets !== 'object') continue;
+
+            for (const [instrumentIdStr, aum] of Object.entries(userAssets)) {
+                const instrumentId = Number(instrumentIdStr);
+                if (isNaN(instrumentId) || !aum) continue;
+
+                const current = instrumentAUM.get(instrumentId) || 0;
+                instrumentAUM.set(instrumentId, current + aum);
+            }
+        }
+
+        // Convert to object
+        const result = {};
+        for (const [instrumentId, totalAUM] of instrumentAUM.entries()) {
+            result[instrumentId] = Number(totalAUM.toFixed(2));
+        }
+
+        this.results['meta'] = result;
+    }
+
+    async getResult() {
+        return this.results;
+    }
+}
+
+module.exports = AggregateAssetAUM;
+

package/calculations/popular-investor/AggregateDailyAUM.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Aggregate Daily AUM Across All Users.
+ * Returns the overall AUM values each day total across all users.
+ */
+
+class AggregateDailyAUM {
+    constructor() {
+        this.results = {};
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            category: 'popular_investor_meta'
+        };
+    }
+
+    static getDependencies() { return ['UserAUM30Day']; }
+
+    static getSchema() {
+        return {
+            type: 'object',
+            additionalProperties: { type: 'number' },
+            description: 'Map of date -> total AUM across all users'
+        };
+    }
+
+    process(context) {
+        const aumData = context.computed['UserAUM30Day'];
+        if (!aumData) {
+            this.results['meta'] = {};
+            return;
+        }
+
+        // Aggregate AUM by date
+        const dateMap = {};
+
+        for (const [userId, userData] of Object.entries(aumData)) {
+            if (userData && typeof userData === 'object' && userData.date && typeof userData.aum === 'number') {
+                const date = userData.date;
+                dateMap[date] = (dateMap[date] || 0) + userData.aum;
+            }
+        }
+
+        // Round values
+        const rounded = {};
+        for (const [date, total] of Object.entries(dateMap)) {
+            rounded[date] = Number(total.toFixed(2));
+        }
+
+        this.results['meta'] = rounded;
+    }
+
+    async getResult() {
+        return this.results;
+    }
+}
+
+module.exports = AggregateDailyAUM;
+

package/calculations/popular-investor/AggregateSectorRanking.js

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview Aggregate Sector Ranking by AUM.
+ * Returns the ranked order of sectors invested in each day across all users (based on AUM).
+ */
+
+class AggregateSectorRanking {
+    constructor() {
+        this.results = {};
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            category: 'popular_investor_meta'
+        };
+    }
+
+    static getDependencies() { return ['UserAUMPerAsset']; }
+
+    static getSchema() {
+        return {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    sector: { type: 'string' },
+                    aum: { type: 'number' },
+                    rank: { type: 'number' }
+                }
+            },
+            description: 'Ranked list of sectors by total AUM invested'
+        };
+    }
+
+    process(context) {
+        const aumPerAssetData = context.computed['UserAUMPerAsset'];
+        const mappings = context.mappings;
+
+        if (!aumPerAssetData || !mappings?.instrumentToSector) {
+            this.results['meta'] = [];
+            return;
+        }
+
+        // Aggregate AUM per sector across all users
+        // Use instrument-to-sector mapping to calculate accurate sector AUM
+        const sectorAUM = new Map();
+
+        for (const [userId, userAssets] of Object.entries(aumPerAssetData)) {
+            if (!userAssets || typeof userAssets !== 'object') continue;
+
+            for (const [instrumentIdStr, aum] of Object.entries(userAssets)) {
+                const instrumentId = Number(instrumentIdStr);
+                if (isNaN(instrumentId) || !aum) continue;
+
+                // Map instrument to sector
+                const sector = mappings.instrumentToSector[instrumentId] || 'Unknown';
+
+                // Add AUM to sector total
+                const current = sectorAUM.get(sector) || 0;
+                sectorAUM.set(sector, current + aum);
+            }
+        }
+
+        // Convert to array and rank
+        const ranked = Array.from(sectorAUM.entries())
+            .map(([sector, aum]) => ({ sector, aum: Number(aum.toFixed(2)) }))
+            .sort((a, b) => b.aum - a.aum)
+            .map((item, index) => ({ ...item, rank: index + 1 }));
+
+        this.results['meta'] = ranked;
+    }
+
+    async getResult() {
+        return this.results;
+    }
+}
+
+module.exports = AggregateSectorRanking;
+

package/calculations/popular-investor/AggregateStockRanking.js

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Aggregate Stock Ranking by AUM.
+ * Returns the ranked order of most invested in stocks each day across all users (based on AUM).
+ */
+
+class AggregateStockRanking {
+    constructor() {
+        this.results = {};
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            category: 'popular_investor_meta'
+        };
+    }
+
+    static getDependencies() { return ['UserAUMPerAsset']; }
+
+    static getSchema() {
+        return {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    instrumentId: { type: 'number' },
+                    ticker: { type: 'string' },
+                    aum: { type: 'number' },
+                    rank: { type: 'number' }
+                }
+            },
+            description: 'Ranked list of stocks by total AUM invested'
+        };
+    }
+
+    process(context) {
+        const aumPerAssetData = context.computed['UserAUMPerAsset'];
+        const mappings = context.mappings;
+
+        if (!aumPerAssetData) {
+            this.results['meta'] = [];
+            return;
+        }
+
+        // Aggregate AUM per instrument across all users
+        const instrumentAUM = new Map();
+
+        for (const [userId, userAssets] of Object.entries(aumPerAssetData)) {
+            if (!userAssets || typeof userAssets !== 'object') continue;
+
+            for (const [instrumentIdStr, aum] of Object.entries(userAssets)) {
+                const instrumentId = Number(instrumentIdStr);
+                if (isNaN(instrumentId) || !aum) continue;
+
+                const current = instrumentAUM.get(instrumentId) || 0;
+                instrumentAUM.set(instrumentId, current + aum);
+            }
+        }
+
+        // Convert to array, add ticker, and rank
+        const ranked = Array.from(instrumentAUM.entries())
+            .map(([instrumentId, aum]) => {
+                const ticker = mappings?.instrumentToTicker?.[instrumentId] || `ID${instrumentId}`;
+                return {
+                    instrumentId,
+                    ticker,
+                    aum: Number(aum.toFixed(2))
+                };
+            })
+            .sort((a, b) => b.aum - a.aum)
+            .map((item, index) => ({ ...item, rank: index + 1 }));
+
+        this.results['meta'] = ranked;
+    }
+
+    async getResult() {
+        return this.results;
+    }
+}
+
+module.exports = AggregateStockRanking;
+

package/calculations/popular-investor/PiCryptoBuyers.js

@@ -0,0 +1,119 @@
+/**
+ * @fileoverview Popular Investors Who Bought Crypto
+ * Returns a list of PI CIDs who bought crypto instruments in the last N days.
+ * Used for dynamic watchlists and alerts.
+ */
+
+class PiCryptoBuyers {
+    constructor() {
+        this.results = {};
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            category: 'popular_investor',
+            rootDataDependencies: ['portfolio', 'history'],
+            userType: 'POPULAR_INVESTOR'
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        return {
+            type: 'object',
+            properties: {
+                cids: {
+                    type: 'array',
+                    items: { type: 'number' },
+                    description: 'List of PI CIDs who bought crypto'
+                },
+                metadata: {
+                    type: 'object',
+                    properties: {
+                        timeWindow: { type: 'number' },
+                        count: { type: 'number' },
+                        timestamp: { type: 'string' }
+                    }
+                }
+            },
+            description: 'PIs who bought crypto in the last N days'
+        };
+    }
+
+    process(context) {
+        const { DataExtractor, HistoryExtractor } = context.math;
+        const portfolio = context.user?.portfolio?.today;
+        const historyDoc = context.user?.history?.today;
+        const mappings = context.mappings;
+        
+        // Default time window: 7 days
+        const TIME_WINDOW_DAYS = 7;
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - TIME_WINDOW_DAYS);
+        
+        // Crypto instrument type IDs (common crypto types in eToro)
+        // InstrumentTypeID 28 = Crypto
+        const CRYPTO_INSTRUMENT_TYPES = [28]; // Can be expanded
+        
+        const cryptoBuyerCIDs = new Set();
+        
+        // Check current portfolio for crypto positions
+        if (portfolio) {
+            const positions = DataExtractor.getPositions(portfolio, 'POPULAR_INVESTOR');
+            
+            for (const pos of positions) {
+                const instrumentType = DataExtractor.getInstrumentTypeId(pos);
+                
+                if (CRYPTO_INSTRUMENT_TYPES.includes(instrumentType)) {
+                    const userId = context.user?.id;
+                    if (userId) {
+                        cryptoBuyerCIDs.add(Number(userId));
+                    }
+                }
+            }
+        }
+        
+        // Check trade history for recent crypto purchases
+        if (historyDoc) {
+            const historyPositions = HistoryExtractor.getHistoryPositions(historyDoc);
+            
+            for (const trade of historyPositions) {
+                const openDate = trade.OpenDateTime ? new Date(trade.OpenDateTime) : null;
+                
+                if (!openDate || openDate < cutoffDate) {
+                    continue; // Too old
+                }
+                
+                // Check if this is a crypto instrument
+                // For now, we'll check if the instrument type is crypto
+                // In a full implementation, we'd use instrument type mapping
+                const instrumentType = trade.InstrumentTypeID || 0;
+                
+                if (CRYPTO_INSTRUMENT_TYPES.includes(instrumentType)) {
+                    const userId = context.user?.id;
+                    if (userId) {
+                        cryptoBuyerCIDs.add(Number(userId));
+                    }
+                }
+            }
+        }
+        
+        this.results['meta'] = {
+            cids: Array.from(cryptoBuyerCIDs),
+            metadata: {
+                timeWindow: TIME_WINDOW_DAYS,
+                count: cryptoBuyerCIDs.size,
+                timestamp: new Date().toISOString()
+            }
+        };
+    }
+
+    async getResult() {
+        return this.results;
+    }
+}
+
+module.exports = PiCryptoBuyers;
+

package/calculations/popular-investor/PiHighVolatility.js

@@ -0,0 +1,133 @@
+/**
+ * @fileoverview Popular Investors with High Volatility Changes
+ * Returns a list of PI CIDs with significant volatility changes.
+ * Used for dynamic watchlists and alerts.
+ */
+
+class PiHighVolatility {
+    constructor() {
+        this.results = {};
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            category: 'popular_investor',
+            rootDataDependencies: ['rankings', 'portfolio'],
+            userType: 'POPULAR_INVESTOR'
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        return {
+            type: 'object',
+            properties: {
+                cids: {
+                    type: 'array',
+                    items: { type: 'number' },
+                    description: 'List of PI CIDs with high volatility changes'
+                },
+                metadata: {
+                    type: 'object',
+                    properties: {
+                        volatilityThreshold: { type: 'number' },
+                        timeWindow: { type: 'number' },
+                        count: { type: 'number' },
+                        timestamp: { type: 'string' }
+                    }
+                }
+            },
+            description: 'PIs with high volatility changes'
+        };
+    }
+
+    process(context) {
+        const { RankingsExtractor, DataExtractor } = context.math;
+        
+        // Default threshold: 50% volatility change
+        const VOLATILITY_THRESHOLD = 0.5; // 50%
+        
+        const rankings = context.user?.rankings;
+        const portfolio = context.user?.portfolio?.today;
+        
+        if (!rankings || !portfolio) {
+            this.results['meta'] = {
+                cids: [],
+                metadata: {
+                    volatilityThreshold: VOLATILITY_THRESHOLD,
+                    timeWindow: 1,
+                    count: 0,
+                    timestamp: new Date().toISOString()
+                }
+            };
+            return;
+        }
+        
+        const todayRankings = rankings.today || {};
+        const yesterdayRankings = rankings.yesterday || {};
+        
+        const todayItems = RankingsExtractor.getItems(todayRankings);
+        const yesterdayItems = RankingsExtractor.getItems(yesterdayRankings);
+        
+        // Create maps for quick lookup
+        const todayMap = new Map();
+        for (const item of todayItems) {
+            if (item.CustomerId) {
+                todayMap.set(String(item.CustomerId), item);
+            }
+        }
+        
+        const yesterdayMap = new Map();
+        for (const item of yesterdayItems) {
+            if (item.CustomerId) {
+                yesterdayMap.set(String(item.CustomerId), item);
+            }
+        }
+        
+        const highVolatilityCIDs = [];
+        
+        // Check each PI for volatility changes
+        for (const [cid, todayItem] of todayMap.entries()) {
+            const yesterdayItem = yesterdayMap.get(cid);
+            
+            if (!yesterdayItem) {
+                continue; // New PI, skip
+            }
+            
+            // Calculate volatility from DailyDD (Daily Drawdown) or WeeklyDD
+            // Using DailyDD as a proxy for volatility
+            const todayDD = todayItem.DailyDD || 0;
+            const yesterdayDD = yesterdayItem.DailyDD || 0;
+            
+            if (yesterdayDD === 0) {
+                continue; // Can't calculate change from zero
+            }
+            
+            // Calculate percentage change in drawdown (volatility proxy)
+            const volatilityChange = Math.abs((todayDD - yesterdayDD) / Math.abs(yesterdayDD));
+            
+            if (volatilityChange >= VOLATILITY_THRESHOLD) {
+                highVolatilityCIDs.push(Number(cid));
+            }
+        }
+        
+        this.results['meta'] = {
+            cids: highVolatilityCIDs,
+            metadata: {
+                volatilityThreshold: VOLATILITY_THRESHOLD,
+                timeWindow: 1,
+                count: highVolatilityCIDs.length,
+                timestamp: new Date().toISOString()
+            }
+        };
+    }
+
+    async getResult() {
+        return this.results;
+    }
+}
+
+module.exports = PiHighVolatility;
+

package/calculations/popular-investor/PiRiskIncrease.js

@@ -0,0 +1,132 @@
+/**
+ * @fileoverview Popular Investors with Risk Score Increase
+ * Returns a list of PI CIDs whose risk score increased by a threshold amount.
+ * Used for dynamic watchlists and alerts.
+ */
+
+class PiRiskIncrease {
+    constructor() {
+        this.results = {};
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            category: 'popular_investor',
+            rootDataDependencies: ['rankings'],
+            userType: 'POPULAR_INVESTOR'
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        return {
+            type: 'object',
+            properties: {
+                cids: {
+                    type: 'array',
+                    items: { type: 'number' },
+                    description: 'List of PI CIDs whose risk score increased'
+                },
+                metadata: {
+                    type: 'object',
+                    properties: {
+                        threshold: { type: 'number' },
+                        timeWindow: { type: 'number' },
+                        count: { type: 'number' },
+                        timestamp: { type: 'string' }
+                    }
+                }
+            },
+            description: 'PIs with risk score increase meeting threshold'
+        };
+    }
+
+    process(context) {
+        const { RankingsExtractor } = context.math;
+        
+        // Default threshold: 2 points increase
+        // This can be parameterized later via computation parameters
+        const RISK_INCREASE_THRESHOLD = 2;
+        
+        // Meta executors process all users, but we need rankings data
+        // For now, we'll access rankings from context.user.rankings
+        // In a full implementation, this would iterate through all PIs
+        const rankings = context.user?.rankings;
+        
+        if (!rankings) {
+            this.results['meta'] = {
+                cids: [],
+                metadata: {
+                    threshold: RISK_INCREASE_THRESHOLD,
+                    timeWindow: 1,
+                    count: 0,
+                    timestamp: new Date().toISOString()
+                }
+            };
+            return;
+        }
+        
+        const todayRankings = rankings.today || {};
+        const yesterdayRankings = rankings.yesterday || {};
+        
+        const todayItems = RankingsExtractor.getItems(todayRankings);
+        const yesterdayItems = RankingsExtractor.getItems(yesterdayRankings);
+        
+        // Create maps for quick lookup
+        const todayMap = new Map();
+        for (const item of todayItems) {
+            if (item.CustomerId) {
+                todayMap.set(String(item.CustomerId), item);
+            }
+        }
+        
+        const yesterdayMap = new Map();
+        for (const item of yesterdayItems) {
+            if (item.CustomerId) {
+                yesterdayMap.set(String(item.CustomerId), item);
+            }
+        }
+        
+        const increasedRiskCIDs = [];
+        
+        // Check each PI in today's rankings
+        for (const [cid, todayItem] of todayMap.entries()) {
+            const yesterdayItem = yesterdayMap.get(cid);
+            
+            if (!yesterdayItem) {
+                // New PI in rankings, skip (no previous data)
+                continue;
+            }
+            
+            const todayRisk = RankingsExtractor.getRiskScore(todayItem);
+            const yesterdayRisk = RankingsExtractor.getRiskScore(yesterdayItem);
+            
+            if (todayRisk !== null && yesterdayRisk !== null) {
+                const riskIncrease = todayRisk - yesterdayRisk;
+                
+                if (riskIncrease >= RISK_INCREASE_THRESHOLD) {
+                    increasedRiskCIDs.push(Number(cid));
+                }
+            }
+        }
+        
+        this.results['meta'] = {
+            cids: increasedRiskCIDs,
+            metadata: {
+                threshold: RISK_INCREASE_THRESHOLD,
+                timeWindow: 1, // 1 day comparison
+                count: increasedRiskCIDs.length,
+                timestamp: new Date().toISOString()
+            }
+        };
+    }
+
+    async getResult() {
+        return this.results;
+    }
+}
+
+module.exports = PiRiskIncrease;
+