aiden-shared-calculations-unified 1.0.64 → 1.0.66

package/calculations/meta/shark_attack_signal.js

@@ -1,60 +1,112 @@
 /**
- * @fileoverview Pass 4: Identifies "Shark Attack" signals where
- * the positive expectancy cohort is buying what the in-loss cohort
- * is panic-selling.
+ * @fileoverview Calculation (Pass 4) for "Shark Attack" signal.
+ *
+ * This signal identifies when the "Smart Cohort" is behaving
+ * differently from both the "Dumb Cohort" and the "In-Loss Cohort"
+ * simultaneously.
+ *
+ * e.g., Smart buying, while Dumb AND Loss cohorts are selling.
+ *
+ * It *depends* on 'smart-cohort-flow', 'dumb-cohort-flow',
+ * and 'in_loss_asset_crowd_flow'.
  */
 class SharkAttackSignal {
+    constructor() {
+        // No per-user processing
+    }
 
-    static getDependencies() {
-        // Depends on Pass 3 "smart" flow and Pass 1 "in-loss" flow
-        return ['positive-expectancy-cohort-flow', 'in-loss-asset-crowd-flow'];
+    /**
+     * Defines the output schema for this calculation.
+     * @returns {object} JSON Schema object
+     */
+    static getSchema() {
+        const signalSchema = {
+            "type": "object",
+            "properties": {
+                "status": {
+                    "type": "string",
+                    "enum": ["Shark Attack (Buy)", "Shark Bait (Sell)", "Neutral"]
+                },
+                "smart_flow_pct": { "type": "number" },
+                "dumb_flow_pct": { "type": "number" },
+                "loss_cohort_flow_pct": { "type": "number" }
+            },
+            "required": ["status", "smart_flow_pct", "dumb_flow_pct", "loss_cohort_flow_pct"]
+        };
+
+        return {
+            "type": "object",
+            "description": "Generates 'Shark Attack' signals where Smart Cohort flow diverges from both Dumb and In-Loss cohorts.",
+            "patternProperties": {
+                "^.*$": signalSchema // Ticker
+            },
+            "additionalProperties": signalSchema
+        };
     }
-    
-    constructor() {
-        this.buyThreshold = 0.005;  // Min "smart" buy-in
-        this.sellThreshold = -0.005; // Min "in-loss" capitulation
+
+    /**
+     * Statically declare dependencies.
+     */
+    static getDependencies() {
+        return [
+            'smart-cohort-flow',      // Pass 3
+            'dumb-cohort-flow',       // Pass 3
+            'in_loss_asset_crowd_flow'// Pass 3
+        ];
     }
 
-    async process(dateStr, dependencies, config, fetchedDependencies) {
-        const { logger } = dependencies;
+    process() {
+        // No-op
+    }
 
-        const smartData = fetchedDependencies['positive-expectancy-cohort-flow'];
-        const lossData = fetchedDependencies['in-loss-asset-crowd-flow'];
+    getResult(fetchedDependencies) {
+        const smartFlowData = fetchedDependencies['smart-cohort-flow']?.assets;
+        const dumbFlowData = fetchedDependencies['dumb-cohort-flow']?.assets;
+        const lossFlowData = fetchedDependencies['in_loss_asset_crowd_flow'];
 
-        if (!smartData || !smartData.asset_flow || !lossData) {
-            logger.log('WARN', `[SharkAttack] Missing computed dependency data for ${dateStr}. Skipping.`);
-            return null;
+        if (!smartFlowData || !dumbFlowData || !lossFlowData) {
+            return {};
         }
 
-        const smartFlow = smartData.asset_flow;
-        const lossFlow = lossData; // This is the root object
-        const signals = {};
+        const allTickers = new Set([
+            ...Object.keys(smartFlowData), 
+            ...Object.keys(dumbFlowData), 
+            ...Object.keys(lossFlowData)
+        ]);
         
-        const allTickers = new Set([...Object.keys(smartFlow), ...Object.keys(lossFlow)]);
+        const result = {};
+        const THRESHOLD = 1.5; // Higher threshold for a stronger signal
 
         for (const ticker of allTickers) {
-            const sFlow = smartFlow[ticker]?.net_crowd_flow_pct || 0;
-            const lFlow = lossFlow[ticker]?.net_crowd_flow_pct || 0;
-
-            // Check for the divergence: Smart is buying, In-Loss is selling
-            if (sFlow >= this.buyThreshold && lFlow <= this.sellThreshold) {
-                
-                signals[ticker] = {
-                    status: "SHARK_ATTACK",
-                    detail: "Positive expectancy cohort is buying from the capitulating in-loss cohort.",
-                    smart_flow: sFlow,
-                    loss_flow: lFlow,
-                    // Calculate a simple conviction score
-                    conviction: sFlow + Math.abs(lFlow) 
-                };
+            const sFlow = smartFlowData[ticker]?.net_flow_percentage || 0;
+            const dFlow = dumbFlowData[ticker]?.net_flow_percentage || 0;
+            const lFlow = lossFlowData[ticker]?.net_flow_percentage || 0;
+            
+            let status = 'Neutral';
+
+            // "Shark Attack": Smart buying, Dumb selling, Loss selling
+            if (sFlow > THRESHOLD && dFlow < -THRESHOLD && lFlow < -THRESHOLD) {
+                status = 'Shark Attack (Buy)';
+            }
+            // "Shark Bait": Smart selling, Dumb buying, Loss buying
+            else if (sFlow < -THRESHOLD && dFlow > THRESHOLD && lFlow > THRESHOLD) {
+                status = 'Shark Bait (Sell)';
             }
-        }
 
-        return signals;
+            result[ticker] = {
+                status: status,
+                smart_flow_pct: sFlow,
+                dumb_flow_pct: dFlow,
+                loss_cohort_flow_pct: lFlow
+            };
+        }
+        
+        return result;
     }
 
-    async getResult() { return null; }
-    reset() {}
+    reset() {
+        // No state
+    }
 }
 
 module.exports = SharkAttackSignal;

package/calculations/meta/smart-dumb-divergence-index.js

@@ -1,127 +1,143 @@
 /**
- * @fileoverview Meta-calculation (Pass 4) that correlates the asset/sector flow
- * of the "Smart Cohort" vs. the "Dumb Cohort" to find divergence signals.
+ * @fileoverview Calculation (Pass 4) for smart-dumb divergence index.
  *
- * --- META REFACTOR (v2) ---
- * This calculation is now stateless. It declares its dependencies and
- * expects them to be passed to its `process` method.
+ * This metric answers: "What divergence signals (e.g., capitulation,
+ * euphoria) can be found by comparing the net asset and sector flow
+ * of the 'smart cohort' vs. the 'dumb cohort'?"
+ *
+ * It *depends* on 'smart-cohort-flow' and 'dumb-cohort-flow'.
  */
-
 class SmartDumbDivergenceIndex {
+    constructor() {
+        // No per-user processing
+    }
 
     /**
-     * (NEW) Statically declare dependencies.
+     * Defines the output schema for this calculation.
+     * @returns {object} JSON Schema object
      */
-    static getDependencies() {
-        return ['smart-cohort-flow', 'dumb-cohort-flow'];
-    }
+    static getSchema() {
+        const signalSchema = {
+            "type": "object",
+            "properties": {
+                "status": {
+                    "type": "string",
+                    "enum": ["Capitulation", "Euphoria", "Confirmation (Buy)", "Confirmation (Sell)", "Divergence (Smart Buy)", "Divergence (Smart Sell)", "Neutral"]
+                },
+                "smart_flow_pct": { "type": "number" },
+                "dumb_flow_pct": { "type": "number" }
+            },
+            "required": ["status", "smart_flow_pct", "dumb_flow_pct"]
+        };
 
-    constructor() {
-        // Minimum net flow (as a percentage) to be considered a signal
-        this.FLOW_THRESHOLD = 0.005; // Formerly 0.5
+        return {
+            "type": "object",
+            "description": "Generates divergence signals by comparing net flow of 'Smart' vs. 'Dumb' cohorts, by asset and sector.",
+            "properties": {
+                "assets": {
+                    "type": "object",
+                    "description": "Divergence signals per asset.",
+                    "patternProperties": { "^.*$": signalSchema }, // Ticker
+                    "additionalProperties": signalSchema
+                },
+                "sectors": {
+                    "type": "object",
+                    "description": "Divergence signals per sector.",
+                    "patternProperties": { "^.*$": signalSchema }, // Sector
+                    "additionalProperties": signalSchema
+                }
+            },
+            "required": ["assets", "sectors"]
+        };
     }
 
     /**
-     * REFACTORED PROCESS METHOD
-     * @param {string} dateStr The date to run the analysis for (e.g., "2025-10-31").
-     * @param {object} dependencies The shared dependencies (db, logger).
-     * @param {object} config The computation system configuration.
-     * @param {object} fetchedDependencies In-memory results from previous passes.
-     * e.g., { 'smart-cohort-flow': ..., 'dumb-cohort-flow': ... }
-     * @returns {Promise<object|null>} The analysis result or null.
+     * Statically declare dependencies.
      */
-    async process(dateStr, dependencies, config, fetchedDependencies) {
-        const { logger } = dependencies;
+    static getDependencies() {
+        return [
+            'smart-cohort-flow', // Pass 3
+            'dumb-cohort-flow'   // Pass 3
+        ];
+    }
 
-        // 1. Get dependencies from the new argument
-        const smartData = fetchedDependencies['smart-cohort-flow'];
-        const dumbData = fetchedDependencies['dumb-cohort-flow'];
-        
-        // 2. Handle missing dependencies
-        if (!smartData || !dumbData) {
-            logger.log('WARN', `[SmartDumbDivergence] Missing cohort flow data dependency for ${dateStr}. Skipping.`);
-            return null;
+    process() {
+        // No-op
+    }
+    
+    _calculateDivergence(smartFlow, dumbFlow) {
+        const result = {};
+        if (!smartFlow || !dumbFlow) {
+            return result;
         }
         
-        const results = {
-            assets: {},
-            sectors: {}
-        };
-        
-        const smartAssetFlow = smartData.asset_flow;
-        const dumbAssetFlow = dumbData.asset_flow;
-        const smartSectorFlow = smartData.sector_rotation;
-        const dumbSectorFlow = dumbData.sector_rotation;
+        const allKeys = new Set([...Object.keys(smartFlow), ...Object.keys(dumbFlow)]);
+        const THRESHOLD = 1; // Min flow %
 
-        if (!smartAssetFlow || !dumbAssetFlow || !smartSectorFlow || !dumbSectorFlow) {
-             logger.log('WARN', `[SmartDumbDivergence] Dependency data for ${dateStr} is incomplete (missing asset_flow or sector_rotation). Skipping.`);
-            return null;
-        }
-
-        // 3. Correlate Assets
-        const allTickers = new Set([...Object.keys(smartAssetFlow), ...Object.keys(dumbAssetFlow)]);
-        for (const ticker of allTickers) {
-            const sFlow = smartAssetFlow[ticker]?.net_crowd_flow_pct || 0;
-            const dFlow = dumbAssetFlow[ticker]?.net_crowd_flow_pct || 0;
+        for (const key of allKeys) {
+            const sFlow = smartFlow[key]?.net_flow_percentage || 0;
+            const dFlow = dumbFlow[key]?.net_flow_percentage || 0;
 
-            const smartBuys = sFlow >= this.FLOW_THRESHOLD;
-            const smartSells = sFlow <= -this.FLOW_THRESHOLD;
-            const dumbBuys = dFlow >= this.FLOW_THRESHOLD;
-            const dumbSells = dFlow <= -this.FLOW_THRESHOLD;
+            let status = 'Neutral';
 
-            let status = 'No_Divergence';
-            let detail = 'Cohorts are aligned or flow is insignificant.';
-
-            if (smartBuys && dumbSells) {
-                status = 'Capitulation';
-                detail = 'Smart cohort is buying the dip from the panic-selling dumb cohort.';
-            } else if (smartSells && dumbBuys) {
-                status = 'Euphoria';
-                detail = 'Smart cohort is selling into the FOMO-buying dumb cohort.';
-            } else if (smartBuys && dumbBuys) {
-                status = 'Aligned_Buy';
-            } else if (smartSells && dumbSells) {
-                status = 'Aligned_Sell';
+            // Both buying
+            if (sFlow > THRESHOLD && dFlow > THRESHOLD) {
+                status = 'Confirmation (Buy)';
             }
-
-            if (status !== 'No_Divergence') {
-                results.assets[ticker] = {
-                    status: status,
-                    detail: detail,
-                    smart_cohort_flow_pct: sFlow,
-                    dumb_cohort_flow_pct: dFlow
-                };
+            // Both selling
+            else if (sFlow < -THRESHOLD && dFlow < -THRESHOLD) {
+                status = 'Confirmation (Sell)';
+            }
+            // Smart buying, Dumb selling
+            else if (sFlow > THRESHOLD && dFlow < -THRESHOLD) {
+                status = 'Capitulation'; // Smart buying the dip from dumb money
+            }
+            // Smart selling, Dumb buying
+            else if (sFlow < -THRESHOLD && dFlow > THRESHOLD) {
+                status = 'Euphoria'; // Smart selling into dumb money fomo
+            }
+            // Smart buying, Dumb neutral
+            else if (sFlow > THRESHOLD && Math.abs(dFlow) < THRESHOLD) {
+                status = 'Divergence (Smart Buy)';
+            }
+            // Smart selling, Dumb neutral
+            else if (sFlow < -THRESHOLD && Math.abs(dFlow) < THRESHOLD) {
+                status = 'Divergence (Smart Sell)';
             }
+            // Dumb buying, Smart neutral
+            else if (dFlow > THRESHOLD && Math.abs(sFlow) < THRESHOLD) {
+                status = 'Divergence (Smart Sell)'; // Implied smart sell
+            }
+            // Dumb selling, Smart neutral
+            else if (dFlow < -THRESHOLD && Math.abs(sFlow) < THRESHOLD) {
+                status = 'Divergence (Smart Buy)'; // Implied smart buy
+            }
+            
+            result[key] = {
+                status: status,
+                smart_flow_pct: sFlow,
+                dumb_flow_pct: dFlow
+            };
         }
-        
-        // 4. Correlate Sectors
-        const allSectors = new Set([...Object.keys(smartSectorFlow), ...Object.keys(dumbSectorFlow)]);
-         for (const sector of allSectors) {
-             const sFlow = smartSectorFlow[sector] || 0;
-             const dFlow = dumbSectorFlow[sector] || 0;
+        return result;
+    }
 
-             let status = 'No_Divergence';
-             
-             if (sFlow > 0 && dFlow < 0) {
-                 status = 'Capitulation';
-             } else if (sFlow < 0 && dFlow > 0) {
-                 status = 'Euphoria';
-             }
+    getResult(fetchedDependencies) {
+        const smartFlowData = fetchedDependencies['smart-cohort-flow'];
+        const dumbFlowData = fetchedDependencies['dumb-cohort-flow'];
 
-            if (status !== 'No_Divergence') {
-                 results.sectors[sector] = {
-                    status: status,
-                    smart_cohort_flow_usd: sFlow,
-                    dumb_cohort_flow_usd: dFlow
-                };
-            }
-         }
+        const assetResult = this._calculateDivergence(smartFlowData?.assets, dumbFlowData?.assets);
+        const sectorResult = this._calculateDivergence(smartFlowData?.sectors, dumbFlowData?.sectors);
 
-        return results;
+        return {
+            assets: assetResult,
+            sectors: sectorResult
+        };
     }
 
-    async getResult() { return null; }
-    reset() {}
+    reset() {
+        // No state
+    }
 }
 
 module.exports = SmartDumbDivergenceIndex;

package/calculations/meta/smart_dumb_divergence_index_v2.js

@@ -1,127 +1,138 @@
 /**
- * @fileoverview Meta-calculation (Pass 4) that correlates the asset/sector flow
- * of the "Smart Cohort" vs. the "Dumb Cohort" to find divergence signals.
+ * @fileoverview Calculation (Pass 5) for smart-dumb divergence v2.
  *
- * --- META REFACTOR (v2) ---
- * This calculation is now stateless. It declares its dependencies and
- * expects them to be passed to its `process` method.
+ * This is a more advanced version that likely uses a different
+ * cohort definition (e.g., 'expectancy' based) and combines more
+ * signals.
+ *
+ * It *depends* on 'positive_expectancy_cohort_flow' and
+ * 'negative_expectancy_cohort_flow'.
  */
-
-class SmartDumbDivergenceIndex {
+class SmartDumbDivergenceIndexV2 {
+    constructor() {
+        // No per-user processing
+    }
 
     /**
-     * (NEW) Statically declare dependencies.
+     * Defines the output schema for this calculation.
+     * @returns {object} JSON Schema object
      */
-    static getDependencies() {
-        return ['positive-expectancy-cohort-flow', 'negative-expectancy-cohort-flow'];
-    }
+    static getSchema() {
+        const signalSchema = {
+            "type": "object",
+            "properties": {
+                "status": {
+                    "type": "string",
+                    "enum": ["Capitulation", "Euphoria", "Confirmation (Buy)", "Confirmation (Sell)", "Divergence (Smart Buy)", "Divergence (Smart Sell)", "Neutral"]
+                },
+                "smart_flow_pct": { "type": "number" },
+                "dumb_flow_pct": { "type": "number" }
+            },
+            "required": ["status", "smart_flow_pct", "dumb_flow_pct"]
+        };
 
-    constructor() {
-        // Minimum net flow (as a percentage) to be considered a signal
-        this.FLOW_THRESHOLD = 0.005; // Formerly 0.5
+        return {
+            "type": "object",
+            "description": "Generates divergence signals (V2) by comparing net flow of 'Positive Expectancy' vs. 'Negative Expectancy' cohorts.",
+            "properties": {
+                "assets": {
+                    "type": "object",
+                    "description": "Divergence signals per asset.",
+                    "patternProperties": { "^.*$": signalSchema }, // Ticker
+                    "additionalProperties": signalSchema
+                },
+                "sectors": {
+                    "type": "object",
+                    "description": "Divergence signals per sector.",
+                    "patternProperties": { "^.*$": signalSchema }, // Sector
+                    "additionalProperties": signalSchema
+                }
+            },
+            "required": ["assets", "sectors"]
+        };
     }
 
     /**
-     * REFACTORED PROCESS METHOD
-     * @param {string} dateStr The date to run the analysis for (e.g., "2025-10-31").
-     * @param {object} dependencies The shared dependencies (db, logger).
-     * @param {object} config The computation system configuration.
-     * @param {object} fetchedDependencies In-memory results from previous passes.
-     * e.g., { 'smart-cohort-flow': ..., 'dumb-cohort-flow': ... }
-     * @returns {Promise<object|null>} The analysis result or null.
+     * Statically declare dependencies.
      */
-    async process(dateStr, dependencies, config, fetchedDependencies) {
-    const { logger } = dependencies;
+    static getDependencies() {
+        return [
+            'positive_expectancy_cohort_flow', // Pass 4
+            'negative_expectancy_cohort_flow'   // Pass 4
+        ];
+    }
 
-        // 1. Get dependencies from the new argument
-        const smartData = fetchedDependencies['positive-expectancy-cohort-flow'];
-        const dumbData = fetchedDependencies['negative-expectancy-cohort-flow'];
-        
-        // 2. Handle missing dependencies
-        if (!smartData || !dumbData) {
-            logger.log('WARN', `[SmartDumbDivergence] Missing cohort flow data dependency for ${dateStr}. Skipping.`);
-            return null;
+    process() {
+        // No-op
+    }
+    
+    _calculateDivergence(smartFlow, dumbFlow) {
+        const result = {};
+        if (!smartFlow || !dumbFlow) {
+            return result;
         }
         
-        const results = {
-            assets: {},
-            sectors: {}
-        };
-        
-        const smartAssetFlow = smartData.asset_flow;
-        const dumbAssetFlow = dumbData.asset_flow;
-        const smartSectorFlow = smartData.sector_rotation;
-        const dumbSectorFlow = dumbData.sector_rotation;
+        const allKeys = new Set([...Object.keys(smartFlow), ...Object.keys(dumbFlow)]);
+        const THRESHOLD = 1; // Min flow %
 
-        if (!smartAssetFlow || !dumbAssetFlow || !smartSectorFlow || !dumbSectorFlow) {
-             logger.log('WARN', `[SmartDumbDivergence] Dependency data for ${dateStr} is incomplete (missing asset_flow or sector_rotation). Skipping.`);
-            return null;
-        }
-
-        // 3. Correlate Assets
-        const allTickers = new Set([...Object.keys(smartAssetFlow), ...Object.keys(dumbAssetFlow)]);
-        for (const ticker of allTickers) {
-            const sFlow = smartAssetFlow[ticker]?.net_crowd_flow_pct || 0;
-            const dFlow = dumbAssetFlow[ticker]?.net_crowd_flow_pct || 0;
+        for (const key of allKeys) {
+            // "Smart" = Positive Expectancy
+            const sFlow = smartFlow[key]?.net_flow_percentage || 0;
+            // "Dumb" = Negative Expectancy
+            const dFlow = dumbFlow[key]?.net_flow_percentage || 0;
 
-            const smartBuys = sFlow >= this.FLOW_THRESHOLD;
-            const smartSells = sFlow <= -this.FLOW_THRESHOLD;
-            const dumbBuys = dFlow >= this.FLOW_THRESHOLD;
-            const dumbSells = dFlow <= -this.FLOW_THRESHOLD;
+            let status = 'Neutral';
 
-            let status = 'No_Divergence';
-            let detail = 'Cohorts are aligned or flow is insignificant.';
-
-            if (smartBuys && dumbSells) {
+            if (sFlow > THRESHOLD && dFlow > THRESHOLD) {
+                status = 'Confirmation (Buy)';
+            }
+            else if (sFlow < -THRESHOLD && dFlow < -THRESHOLD) {
+                status = 'Confirmation (Sell)';
+            }
+            else if (sFlow > THRESHOLD && dFlow < -THRESHOLD) {
                 status = 'Capitulation';
-                detail = 'Smart cohort is buying the dip from the panic-selling dumb cohort.';
-            } else if (smartSells && dumbBuys) {
+            }
+            else if (sFlow < -THRESHOLD && dFlow > THRESHOLD) {
                 status = 'Euphoria';
-                detail = 'Smart cohort is selling into the FOMO-buying dumb cohort.';
-            } else if (smartBuys && dumbBuys) {
-                status = 'Aligned_Buy';
-            } else if (smartSells && dumbSells) {
-                status = 'Aligned_Sell';
             }
-
-            if (status !== 'No_Divergence') {
-                results.assets[ticker] = {
-                    status: status,
-                    detail: detail,
-                    smart_cohort_flow_pct: sFlow,
-                    dumb_cohort_flow_pct: dFlow
-                };
+            else if (sFlow > THRESHOLD && Math.abs(dFlow) < THRESHOLD) {
+                status = 'Divergence (Smart Buy)';
+            }
+            else if (sFlow < -THRESHOLD && Math.abs(dFlow) < THRESHOLD) {
+                status = 'Divergence (Smart Sell)';
             }
+            else if (dFlow > THRESHOLD && Math.abs(sFlow) < THRESHOLD) {
+                status = 'Divergence (Smart Sell)'; // Implied
+            }
+            else if (dFlow < -THRESHOLD && Math.abs(sFlow) < THRESHOLD) {
+                status = 'Divergence (Smart Buy)'; // Implied
+            }
+            
+            result[key] = {
+                status: status,
+                smart_flow_pct: sFlow,
+                dumb_flow_pct: dFlow
+            };
         }
-        
-        // 4. Correlate Sectors
-        const allSectors = new Set([...Object.keys(smartSectorFlow), ...Object.keys(dumbSectorFlow)]);
-         for (const sector of allSectors) {
-             const sFlow = smartSectorFlow[sector] || 0;
-             const dFlow = dumbSectorFlow[sector] || 0;
+        return result;
+    }
 
-             let status = 'No_Divergence';
-             
-             if (sFlow > 0 && dFlow < 0) {
-                 status = 'Capitulation';
-             } else if (sFlow < 0 && dFlow > 0) {
-                 status = 'Euphoria';
-             }
+    getResult(fetchedDependencies) {
+        const smartFlowData = fetchedDependencies['positive_expectancy_cohort_flow'];
+        const dumbFlowData = fetchedDependencies['negative_expectancy_cohort_flow'];
 
-            if (status !== 'No_Divergence') {
-                 results.sectors[sector] = {
-                    status: status,
-                    smart_cohort_flow_usd: sFlow,
-                    dumb_cohort_flow_usd: dFlow
-                };
-            }
-         }
+        const assetResult = this._calculateDivergence(smartFlowData?.assets, dumbFlowData?.assets);
+        const sectorResult = this._calculateDivergence(smartFlowData?.sectors, dumbFlowData?.sectors);
 
-        return results;
+        return {
+            assets: assetResult,
+            sectors: sectorResult
+        };
     }
 
-    async getResult() { return null; }
-    reset() {}
+    reset() {
+        // No state
+    }
 }
 
-module.exports = SmartDumbDivergenceIndex;
+module.exports = SmartDumbDivergenceIndexV2;