aiden-shared-calculations-unified 1.0.27 → 1.0.29

package/calculations/behavioural/historical/asset_crowd_flow.js

@@ -81,64 +81,85 @@ class AssetCrowdFlow {
 
     async getResult() {
         if (this.user_count === 0 || !this.dates.today) {
-            return {}; // No users processed or dates not found
+            console.warn('[AssetCrowdFlow] No users processed or dates missing.');
+            return {};
         }
 
-        // Load dependencies (prices and mappings) in parallel
+        // Load priceMap and mappings if not loaded
         if (!this.priceMap || !this.mappings) {
-            const [priceData, mappingData] = await Promise.all([
-                loadAllPriceData(),
-                loadInstrumentMappings()
-            ]);
-            this.priceMap = priceData;
-            this.mappings = mappingData;
+            try {
+                const [priceData, mappingData] = await Promise.all([
+                    loadAllPriceData(),
+                    loadInstrumentMappings()
+                ]);
+                this.priceMap = priceData;
+                this.mappings = mappingData;
+            } catch (err) {
+                console.error('[AssetCrowdFlow] Failed to load dependencies:', err);
+                return {};
+            }
         }
-        
+
         const finalResults = {};
         const todayStr = this.dates.today;
         const yesterdayStr = this.dates.yesterday;
 
-        for (const instrumentId in this.asset_values) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
-            
-            // 1. Calculate average % values
-            const avg_day1_value = this.asset_values[instrumentId].day1_value_sum / this.user_count;
-            const avg_day2_value = this.asset_values[instrumentId].day2_value_sum / this.user_count;
-            
-            // 2. Get the actual price change
-            const priceChangePct = getDailyPriceChange(instrumentId, yesterdayStr, todayStr, this.priceMap);
+        for (const rawInstrumentId in this.asset_values) {
+            const instrumentId = String(rawInstrumentId); // normalize
+            const ticker = this.mappings.instrumentToTicker?.[instrumentId] || `id_${instrumentId}`;
+
+            const avg_day1_value = this.asset_values[rawInstrumentId].day1_value_sum / this.user_count;
+            const avg_day2_value = this.asset_values[rawInstrumentId].day2_value_sum / this.user_count;
+
+            let priceChangePct = null;
+
+            // Check priceMap presence
+            if (!this.priceMap || !this.priceMap[instrumentId]) {
+                console.debug(`[AssetCrowdFlow] Missing priceMap entry for instrumentId ${instrumentId} (${ticker})`);
+            } else {
+                const priceDay1 = this.priceMap[instrumentId][yesterdayStr];
+                const priceDay2 = this.priceMap[instrumentId][todayStr];
+
+                if (priceDay1 == null) console.debug(`[AssetCrowdFlow] Missing price for ${instrumentId} (${ticker}) on ${yesterdayStr}`);
+                if (priceDay2 == null) console.debug(`[AssetCrowdFlow] Missing price for ${instrumentId} (${ticker}) on ${todayStr}`);
+
+                if (priceDay1 != null && priceDay2 != null && priceDay1 > 0) {
+                    priceChangePct = (priceDay2 - priceDay1) / priceDay1;
+                }
+            }
 
             if (priceChangePct === null) {
-                // Cannot calculate if price data is missing for either day
                 finalResults[ticker] = {
                     net_crowd_flow_pct: 0,
-                    error: "Missing price data for calculation."
+                    avg_value_day1: avg_day1_value,
+                    avg_value_day2: avg_day2_value,
+                    price_change_pct: null,
+                    user_sample_size: this.user_count,
+                    warning: 'Missing price data for calculation'
                 };
                 continue;
             }
 
-            // 3. Calculate the expected value (the "price-move" effect)
-            // We use avg_day1_value as the base. The cash flow proxy calculation
-            // uses (avg_value - avg_invested) because it's solving for a different unknown.
-            // Here, we are solving for flow *relative to the asset itself*.
+            // Calculate expected day2 value from price movement
             const expected_day2_value = avg_day1_value * (1 + priceChangePct);
 
-            // 4. Find the signal (the "crowd-flow" effect)
+            // Net crowd flow = actual minus expected
             const net_crowd_flow_pct = avg_day2_value - expected_day2_value;
 
             finalResults[ticker] = {
-                net_crowd_flow_pct: net_crowd_flow_pct,
-                avg_value_day1_pct: avg_day1_value,
-                avg_value_day2_pct: avg_day2_value,
-                expected_value_day2_pct: expected_day2_value,
+                net_crowd_flow_pct,
+                avg_value_day1,
+                avg_value_day2,
+                expected_day2_value,
                 price_change_pct: priceChangePct,
                 user_sample_size: this.user_count
             };
         }
-        
+
         return finalResults;
     }
 
+
     reset() {
         this.asset_values = {};
         this.user_count = 0;

package/calculations/capital_flow/historical/crowd-cash-flow-proxy.js

@@ -0,0 +1,122 @@
+/**
+ * @fileoverview Estimates a proxy for net crowd cash flow (Deposits vs. Withdrawals)
+ * by aggregating portfolio percentage changes across all users.
+ *
+ * This calculation is based on the formula:
+ * Total_Change = P/L_Effect + Trading_Effect + Cash_Flow_Effect
+ *
+ * Where:
+ * - Total_Change = avg_value_day2 - avg_value_day1
+ * - P/L_Effect = avg_value_day1 - avg_invested_day1
+ * - Trading_Effect = avg_invested_day2 - avg_invested_day1
+ *
+ * We solve for Cash_Flow_Effect, which serves as our proxy.
+ * A negative value indicates a net DEPOSIT (denominator grew, shrinking all %s).
+ * A positive value indicates a net WITHDRAWAL (denominator shrank, inflating all %s).
+ *
+ * NOTE: This file is a logical duplicate of deposit_withdrawal_percentage.js
+ * to satisfy the hardcoded 'crowd-cash-flow-proxy' dependency in several
+ * meta-calculations.
+ */
+
+class CrowdCashFlowProxy {
+    constructor() {
+        this.total_invested_day1 = 0;
+        this.total_value_day1 = 0;
+        this.total_invested_day2 = 0;
+        this.total_value_day2 = 0;
+        this.user_count = 0;
+    }
+
+    /**
+     * Helper to sum a specific field from an AggregatedPositions array.
+     * @param {Array<object>} positions - The AggregatedPositions array.
+     * @param {string} field - The field to sum ('Invested' or 'Value').
+     * @returns {number} The total sum of that field.
+     */
+    _sumPositions(positions, field) {
+        if (!positions || !Array.isArray(positions)) {
+            return 0;
+        }
+        return positions.reduce((sum, pos) => sum + (pos[field] || 0), 0);
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId) {
+        // This calculation requires both days' data to compare
+        if (!todayPortfolio || !yesterdayPortfolio || !todayPortfolio.AggregatedPositions || !yesterdayPortfolio.AggregatedPositions) {
+            return;
+        }
+
+        const invested_day1 = this._sumPositions(yesterdayPortfolio.AggregatedPositions, 'Invested');
+        const value_day1 = this._sumPositions(yesterdayPortfolio.AggregatedPositions, 'Value');
+        const invested_day2 = this._sumPositions(todayPortfolio.AggregatedPositions, 'Invested');
+        const value_day2 = this._sumPositions(todayPortfolio.AggregatedPositions, 'Value');
+
+        // Only include users who have some form of positions
+        if (invested_day1 === 0 && invested_day2 === 0 && value_day1 === 0 && value_day2 === 0) {
+            return;
+        }
+
+        this.total_invested_day1 += invested_day1;
+        this.total_value_day1 += value_day1;
+        this.total_invested_day2 += invested_day2;
+        this.total_value_day2 += value_day2;
+        this.user_count++;
+    }
+
+    getResult() {
+        if (this.user_count === 0) {
+            return {}; // No users processed, return empty.
+        }
+
+        // 1. Calculate the average portfolio for the crowd
+        const avg_invested_day1 = this.total_invested_day1 / this.user_count;
+        const avg_value_day1 = this.total_value_day1 / this.user_count;
+        const avg_invested_day2 = this.total_invested_day2 / this.user_count;
+        const avg_value_day2 = this.total_value_day2 / this.user_count;
+
+        // 2. Isolate the three effects
+        const total_value_change = avg_value_day2 - avg_value_day1;
+        const pl_effect = avg_value_day1 - avg_invested_day1;
+        const trading_effect = avg_invested_day2 - avg_invested_day1;
+
+        // 3. Solve for the Cash Flow Effect
+        // Total_Change = pl_effect + trading_effect + cash_flow_effect
+        const cash_flow_effect = total_value_change - pl_effect - trading_effect;
+
+        return {
+            // The final proxy value.
+            // A negative value signals a net DEPOSIT.
+            // A positive value signals a net WITHDRAWAL.
+            cash_flow_effect_proxy: cash_flow_effect,
+            
+            // Interpretation for the frontend
+            interpretation: "A negative value signals a net crowd deposit. A positive value signals a net crowd withdrawal.",
+            
+            // Debug components
+            components: {
+                total_value_change: total_value_change,
+                pl_effect: pl_effect,
+                trading_effect: trading_effect
+            },
+            // Debug averages
+            averages: {
+                avg_invested_day1: avg_invested_day1,
+                avg_value_day1: avg_value_day1,
+                avg_invested_day2: avg_invested_day2,
+                avg_value_day2: avg_value_day2
+            },
+            user_sample_size: this.user_count
+        };
+    }
+
+    reset() {
+        this.total_invested_day1 = 0;
+        this.total_value_day1 = 0;
+        this.total_invested_day2 = 0;
+        this.total_value_day2 = 0;
+        this.user_count = 0;
+    }
+}
+
+module.exports = CrowdCashFlowProxy;

package/package.json

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