aiden-shared-calculations-unified 1.0.10 → 1.0.11

package/calculations/capital_flow/deposit_withdrawal_percentage.js

@@ -1,71 +1,118 @@
 /**
- * @fileoverview Estimates the average percentage deposited into accounts between two days.
+ * @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).
  */
 
-class DepositPercentage {
+class CrowdCashFlowProxy {
     constructor() {
-        this.totalDepositPercentage = 0;
-        this.userCount = 0;
+        this.total_invested_day1 = 0;
+        this.total_value_day1 = 0;
+        this.total_invested_day2 = 0;
+        this.total_value_day2 = 0;
+        this.user_count = 0;
     }
 
     /**
-     * Calculates total PnL from aggregated or public positions.
-     * @param {object} portfolio - Portfolio data object.
-     * @returns {number|null} Total PnL or null if positions are missing.
+     * 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.
      */
-    calculateTotalPnl(portfolio) {
-        // Use the same logic as in ProfitabilityMigration
-        if (portfolio && portfolio.AggregatedPositions) {
-            return portfolio.AggregatedPositions.reduce((sum, pos) => sum + (pos.NetProfit || 0), 0);
-        } else if (portfolio && portfolio.PublicPositions) {
-            // PublicPositions might lack NetProfit, adjust if necessary based on your data
-            return portfolio.PublicPositions.reduce((sum, pos) => sum + (pos.NetProfit || 0), 0);
+    _sumPositions(positions, field) {
+        if (!positions || !Array.isArray(positions)) {
+            return 0;
         }
-        return null;
+        return positions.reduce((sum, pos) => sum + (pos[field] || 0), 0);
     }
 
     process(todayPortfolio, yesterdayPortfolio, userId) {
-        if (!todayPortfolio || !yesterdayPortfolio || !yesterdayPortfolio.PortfolioValue || yesterdayPortfolio.PortfolioValue === 0) {
-            // Need both portfolios and a non-zero yesterday value for calculation
+        // This calculation requires both days' data to compare
+        if (!todayPortfolio || !yesterdayPortfolio || !todayPortfolio.AggregatedPositions || !yesterdayPortfolio.AggregatedPositions) {
             return;
         }
 
-        const valueChange = (todayPortfolio.PortfolioValue || 0) - yesterdayPortfolio.PortfolioValue;
+        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');
 
-        const todayPnl = this.calculateTotalPnl(todayPortfolio);
-        const yesterdayPnl = this.calculateTotalPnl(yesterdayPortfolio);
-
-        // If PnL can't be calculated for either day, we can't reliably estimate cash flow
-        if (todayPnl === null || yesterdayPnl === null) {
+        // Only include users who have some form of positions
+        if (invested_day1 === 0 && invested_day2 === 0 && value_day1 === 0 && value_day2 === 0) {
             return;
         }
 
-        const pnlChange = todayPnl - yesterdayPnl;
-        const cashFlow = valueChange - pnlChange;
-
-        // Check for deposit (positive cash flow)
-        if (cashFlow > 0) {
-            const depositPercentage = (cashFlow / yesterdayPortfolio.PortfolioValue) * 100;
-            this.totalDepositPercentage += depositPercentage;
-            this.userCount++;
-        }
+        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.userCount === 0) {
-            return {}; // Return empty object if no users contributed
+        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 {
-            // Calculate the final average directly
-            average_deposit_percentage: this.totalDepositPercentage / this.userCount
+            // 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.totalDepositPercentage = 0;
-        this.userCount = 0;
+        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 = DepositPercentage;
+module.exports = CrowdCashFlowProxy;

package/package.json

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