bulltrackers-module 1.0.176 → 1.0.178

package/functions/computation-system/controllers/computation_controller.js

@@ -147,28 +147,17 @@ class ComputationExecutor {
      */
     async executePerUser(calcInstance, metadata, dateStr, portfolioData, yesterdayPortfolioData, historyData, computedDeps, prevDeps) {
         const { logger } = this.deps;
-        
-        // Fix for the 'all' userType discrepancy:
-        const targetUserType = metadata.userType; // 'all', 'normal', or 'speculator'
-
+        const targetUserType = metadata.userType; 
         const mappings = await this.loader.loadMappings();
         const insights = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
-
         for (const [userId, todayPortfolio] of Object.entries(portfolioData)) {
-            // 1. Get Yesterday's Portfolio (if available)
             const yesterdayPortfolio = yesterdayPortfolioData ? yesterdayPortfolioData[userId] : null;
-            
-            // 2. Get Today's Trading History (if available)
             const todayHistory = historyData ? historyData[userId] : null;
-
             const actualUserType = todayPortfolio.PublicPositions ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
-            
-            // Filtering Logic
             if (targetUserType !== 'all') {
                  const mappedTarget = (targetUserType === 'speculator') ? SCHEMAS.USER_TYPES.SPECULATOR : SCHEMAS.USER_TYPES.NORMAL;
                  if (mappedTarget !== actualUserType) continue;
             }
-
             const context = ContextBuilder.buildPerUserContext({
                 todayPortfolio, yesterdayPortfolio,
                 todayHistory, 
@@ -177,7 +166,6 @@ class ComputationExecutor {
                 previousComputedDependencies: prevDeps,
                 config: this.config, deps: this.deps
             });
-
             try { await calcInstance.process(context); } 
             catch (e) { logger.log('WARN', `Calc ${metadata.name} failed for user ${userId}: ${e.message}`); }
         }
@@ -187,14 +175,12 @@ class ComputationExecutor {
         const mappings = await this.loader.loadMappings();
         const insights = metadata.rootDataDependencies?.includes('insights') ? { today: await this.loader.loadInsights(dateStr) } : null;
         const social = metadata.rootDataDependencies?.includes('social') ? { today: await this.loader.loadSocial(dateStr) } : null;
-
         const context = ContextBuilder.buildMetaContext({
             dateStr, metadata, mappings, insights, socialData: social,
             computedDependencies: computedDeps,
             previousComputedDependencies: prevDeps,
             config: this.config, deps: this.deps
         });
-
         return await calcInstance.process(context);
     }
 }

package/functions/computation-system/helpers/computation_manifest_builder.js

@@ -11,15 +11,6 @@
  * It has removed all logic for deprecated folder structures (e.g., /historical/).
  */
 
-const fs                 = require('fs');
-//Hacky solution to force tmp writes TODO : This Tmp write is really dodgy, not ideal but works, consider less hacky solutions to writing to filesystem
-process.env.TMPDIR = '/tmp';
-process.env.TMP    = '/tmp';
-process.env.TEMP   = '/tmp';
-const os           = require('os');
-
- const path = require('path');
-
 /* --------------------------------------------------
  * Pretty Console Helpers
  * -------------------------------------------------- */
@@ -54,7 +45,7 @@ function suggestClosest(name, candidates, n = 3) {
         return dp[m][n];
     };
     const scores = candidates.map(c => [c, levenshtein(name, c)]);
-    scores.sort((a, b) => a[1] - b[1]);
+    scores.sort((a, b)              => a[1] - b[1]);
     return scores.slice(0, n).map(s => s[0]);
 }
 
@@ -206,17 +197,20 @@ function buildManifest(productLinesToRun = [], calculations) {
     const sortedManifest = [];
     const queue          = [];
     let maxPass          = 0;
+
     for (const [name, degree] of filteredInDegree) { if (degree === 0) { queue.push(name); filteredManifestMap.get(name).pass = 1; maxPass = 1; } }
     queue.sort();
     while (queue.length) {
         const currentName = queue.shift();
         const currentEntry = filteredManifestMap.get(currentName);
         sortedManifest.push(currentEntry);
+        
         for (const neighborName of (filteredReverseAdjacency.get(currentName) || [])) { const newDegree = filteredInDegree.get(neighborName) - 1; filteredInDegree.set(neighborName, newDegree);
             const neighborEntry = filteredManifestMap.get(neighborName);
             if (neighborEntry.pass <= currentEntry.pass) { neighborEntry.pass = currentEntry.pass + 1; if (neighborEntry.pass > maxPass) maxPass = neighborEntry.pass; }
             if (newDegree === 0) { queue.push(neighborName); } }
         queue.sort(); }
+
     if (sortedManifest.length !== filteredManifestMap.size) {
         log.divider('Circular Dependency Detected');
         const cycles = findCycles(filteredManifestMap, adjacency);

package/functions/computation-system/helpers/computation_pass_runner.js

@@ -62,8 +62,6 @@ async function runComputationPass(config, dependencies, computationManifest) {
     // Process a single date and RETURN updates (do not write)
     const processDate = async (dateStr) => {
         const dateToProcess = new Date(dateStr + 'T00:00:00Z');
-
-        // Filter using in-memory status
         const standardToRun = standardCalcs.filter(c => shouldRun(c, dateStr));
         const metaToRun     = metaCalcs.filter(c => shouldRun(c, dateStr));
         
@@ -84,21 +82,17 @@ async function runComputationPass(config, dependencies, computationManifest) {
         try {
             const calcsRunning = [...finalStandardToRun, ...finalMetaToRun];
             const existingResults = await fetchExistingResults(dateStr, calcsRunning, computationManifest, config, dependencies, false);
-            
-            const prevDate = new Date(dateToProcess); prevDate.setUTCDate(prevDate.getUTCDate() - 1);
-            const prevDateStr = prevDate.toISOString().slice(0, 10);
+            const prevDate        = new Date(dateToProcess); prevDate.setUTCDate(prevDate.getUTCDate() - 1);
+            const prevDateStr     = prevDate.toISOString().slice(0, 10);
             const previousResults = await fetchExistingResults(prevDateStr, calcsRunning, computationManifest, config, dependencies, true);
-
             if (finalStandardToRun.length) {
                 const updates = await runStandardComputationPass(dateToProcess, finalStandardToRun, `Pass ${passToRun} (Std)`, config, dependencies, rootData, existingResults, previousResults, true); // skipStatusWrite=true
                 Object.assign(dateUpdates, updates);
             }
-            
             if (finalMetaToRun.length) {
                 const updates = await runMetaComputationPass(dateToProcess, finalMetaToRun, `Pass ${passToRun} (Meta)`, config, dependencies, existingResults, previousResults, rootData, true); // skipStatusWrite=true
                 Object.assign(dateUpdates, updates);
             }
-            
         } catch (err) { 
             logger.log('ERROR', `[PassRunner] FAILED Pass ${passToRun} for ${dateStr}`, { errorMessage: err.message });
             // Mark failures

package/functions/task-engine/helpers/update_helpers.js

@@ -3,6 +3,7 @@
  * (REFACTORED: Removed all concurrency from `handleUpdate` and `lookupUsernames`)
  * (REFACTORED: Added node-fetch fallback for all API calls)
  * (REFACTORED: Added verbose, user-centric logging for all operations)
+ * (FIXED: Resolved ReferenceError 'instId is not defined' in final timestamp loops)
  */
 
 const { FieldValue } = require('@google-cloud/firestore');
@@ -15,54 +16,83 @@ async function lookupUsernames(cids, { logger, headerManager, proxyManager }, co
     if (!cids?.length) return [];
     logger.log('INFO', `[lookupUsernames] Looking up usernames for ${cids.length} CIDs.`);
     
-    // --- Set concurrency to 1 because appscript gets really fucked up with undocumented rate limits if we try spam it concurrently, a shame but that's life. DO NOT CHANGE THIS
+    // --- Set concurrency to 1 to prevent AppScript rate limits. DO NOT CHANGE THIS.
     const limit = pLimit(1);
     const { USERNAME_LOOKUP_BATCH_SIZE, ETORO_API_RANKINGS_URL } = config;
     const batches = [];
-    for (let i = 0; i < cids.length; i += USERNAME_LOOKUP_BATCH_SIZE) { batches.push(cids.slice(i, i + USERNAME_LOOKUP_BATCH_SIZE).map(Number)); }
-    const batchPromises = batches.map((batch, index) => limit(async () => { const batchId = `batch-${index + 1}`;
+    for (let i = 0; i < cids.length; i += USERNAME_LOOKUP_BATCH_SIZE) { 
+        batches.push(cids.slice(i, i + USERNAME_LOOKUP_BATCH_SIZE).map(Number)); 
+    }
+
+    const batchPromises = batches.map((batch, index) => limit(async () => { 
+        const batchId = `batch-${index + 1}`;
         logger.log('INFO', `[lookupUsernames/${batchId}] Processing batch of ${batch.length} CIDs...`);
         const header = await headerManager.selectHeader();
         if (!header) { logger.log('ERROR', `[lookupUsernames/${batchId}] Could not select a header.`); return null; }
+        
         let wasSuccess = false;
         let proxyUsed = true;
         let response;
         const url = `${ETORO_API_RANKINGS_URL}?Period=LastTwoYears`;
         const options = { method: 'POST', headers: { ...header.header, 'Content-Type': 'application/json' }, body: JSON.stringify(batch) };
+        
         try {
             logger.log('TRACE', `[lookupUsernames/${batchId}] Attempting fetch via AppScript proxy...`);
             response = await proxyManager.fetch(url, options);
             if (!response.ok) throw new Error(`AppScript proxy failed with status ${response.status}`);
-            wasSuccess = true; // Yay we win
+            wasSuccess = true;
             logger.log('INFO', `[lookupUsernames/${batchId}] AppScript proxy fetch successful.`);
-        } catch (proxyError) { logger.log('WARN', `[lookupUsernames/${batchId}] AppScript proxy fetch FAILED. Error: ${proxyError.message}. Attempting direct node-fetch fallback.`, { error: proxyError.message, source: 'AppScript' }); // SHIT we failed...
-            proxyUsed = false; // Don't penalize header for proxy failure
-            try { response = await fetch(url, options);  // Ok let's try again with node, using GCP IP pools
-                if (!response.ok) { const errorText = await response.text(); throw new Error(`Direct fetch failed with status ${response.status}. Response: ${errorText.substring(0, 200)}`); }
-                logger.log('INFO', `[lookupUsernames/${batchId}] Direct node-fetch fallback successful.`); // Yay we win
-            } catch (fallbackError) { logger.log('ERROR', `[lookupUsernames/${batchId}] Direct node-fetch fallback FAILED. Giving up on this batch.`, { error: fallbackError.message, source: 'eToro/Network' }); // SHIT, we failed here too
-                return null; // Give up on this batch
+        } catch (proxyError) { 
+            logger.log('WARN', `[lookupUsernames/${batchId}] AppScript proxy fetch FAILED. Error: ${proxyError.message}. Attempting direct node-fetch fallback.`, { error: proxyError.message, source: 'AppScript' });
+            proxyUsed = false; 
+            try { 
+                response = await fetch(url, options); 
+                if (!response.ok) { 
+                    const errorText = await response.text(); 
+                    throw new Error(`Direct fetch failed with status ${response.status}. Response: ${errorText.substring(0, 200)}`); 
+                }
+                logger.log('INFO', `[lookupUsernames/${batchId}] Direct node-fetch fallback successful.`);
+            } catch (fallbackError) { 
+                logger.log('ERROR', `[lookupUsernames/${batchId}] Direct node-fetch fallback FAILED. Giving up on this batch.`, { error: fallbackError.message, source: 'eToro/Network' });
+                return null;
             }
-        } finally { if (proxyUsed) { headerManager.updatePerformance(header.id, wasSuccess); } } // If we used Appscript IP Pool and not GCP IP Pool, record performance
-        try { const data = await response.json(); return data;
-        } catch (parseError) { logger.log('ERROR', `[lookupUsernames/${batchId}] Failed to parse JSON response.`, { error: parseError.message }); return null; } }));
+        } finally { 
+            if (proxyUsed) { headerManager.updatePerformance(header.id, wasSuccess); } 
+        } 
+        
+        try { 
+            const data = await response.json(); 
+            return data;
+        } catch (parseError) { 
+            logger.log('ERROR', `[lookupUsernames/${batchId}] Failed to parse JSON response.`, { error: parseError.message }); 
+            return null; 
+        } 
+    }));
 
     const results  = await Promise.allSettled(batchPromises);
-    const allUsers = results .filter(r => r.status === 'fulfilled' && r.value && Array.isArray(r.value)) .flatMap(r => r.value); 
+    const allUsers = results
+        .filter(r => r.status === 'fulfilled' && r.value && Array.isArray(r.value))
+        .flatMap(r => r.value); 
+    
     logger.log('INFO', `[lookupUsernames] Found ${allUsers.length} public users out of ${cids.length}.`);
     return allUsers;
 }
 
 
 /**
- * (REFACTORED: Fully sequential, verbose logging, node-fetch fallback)
+ * (REFACTORED: Fully sequential, verbose logging, node-fetch fallback, FIXED SCOPING)
  */
 async function handleUpdate(task, taskId, { logger, headerManager, proxyManager, db, batchManager }, config, username) {
     const { userId, instruments, instrumentId, userType } = task;
-    const instrumentsToProcess = userType === 'speculator'  ? (instruments || [instrumentId]) : [undefined]; 
+    
+    // For normal users, we pass [undefined] so the loop runs exactly once.
+    // For speculators, we pass the list of instruments to fetch individually.
+    const instrumentsToProcess = userType === 'speculator' ? (instruments || [instrumentId]) : [undefined]; 
+    
     const today = new Date().toISOString().slice(0, 10);
     const portfolioBlockId = `${Math.floor(parseInt(userId) / 1000000)}M`;
     let isPrivate = false;
+
     logger.log('INFO', `[handleUpdate/${userId}] Starting update task. Type: ${userType}. Instruments: ${instrumentsToProcess.join(', ')}`);
 
     // --- 1. Process History Fetch (Sequentially) ---
@@ -74,52 +104,70 @@ async function handleUpdate(task, taskId, { logger, headerManager, proxyManager,
         if (!batchManager.checkAndSetHistoryFetched(userId)) {
             logger.log('INFO', `[handleUpdate/${userId}] Attempting history fetch.`);
             historyHeader = await headerManager.selectHeader();
-            if (!historyHeader) { logger.log('WARN', `[handleUpdate/${userId}] Could not select history header. Skipping history.`);
+            if (!historyHeader) { 
+                logger.log('WARN', `[handleUpdate/${userId}] Could not select history header. Skipping history.`);
             } else {
                 const historyUrl = `${config.ETORO_API_USERSTATS_URL}${username}/trades/oneYearAgo?CopyAsAsset=true`;
                 const options = { headers: historyHeader.header };
                 let response;
-                try { logger.log('TRACE', `[handleUpdate/${userId}] Attempting history fetch via AppScript proxy...`);
+                
+                try { 
+                    logger.log('TRACE', `[handleUpdate/${userId}] Attempting history fetch via AppScript proxy...`);
                     response = await proxyManager.fetch(historyUrl, options);
-                    if (!response.ok) throw new Error(`AppScript proxy failed with status ${response.status}`); // SHIT we failed here
-                    wasHistorySuccess = true; // Appscript worked, we are very smart
-                    
+                    if (!response.ok) throw new Error(`AppScript proxy failed with status ${response.status}`);
+                    wasHistorySuccess = true;
                 } catch (proxyError) {
-                    logger.log('WARN', `[handleUpdate/${userId}] History fetch via AppScript proxy FAILED. Error: ${proxyError.message}. Attempting direct node-fetch fallback.`, { error: proxyError.message, source: 'AppScript' }); // SHIT we failed here
+                    logger.log('WARN', `[handleUpdate/${userId}] History fetch via AppScript proxy FAILED. Error: ${proxyError.message}. Attempting direct node-fetch fallback.`, { error: proxyError.message, source: 'AppScript' });
                     proxyUsedForHistory = false;
-                    try { response = await fetch(historyUrl, options);
-                        if (!response.ok) { const errorText = await response.text(); 
-                            throw new Error(`Direct fetch failed with status ${response.status}. Response: ${errorText.substring(0, 200)}`); } // SHIT we failed here too
-                        wasHistorySuccess = true; // Fallback succeeded, we are so smart
-                        
-                    } catch (fallbackError) { logger.log('ERROR', `[handleUpdate/${userId}] History fetch direct fallback FAILED.`, { error: fallbackError.message, source: 'eToro/Network' }); // We are dumb, everything failed
-                        wasHistorySuccess = false; // Nope we are dumb....
+                    try { 
+                        response = await fetch(historyUrl, options);
+                        if (!response.ok) { 
+                            const errorText = await response.text(); 
+                            throw new Error(`Direct fetch failed with status ${response.status}. Response: ${errorText.substring(0, 200)}`); 
+                        }
+                        wasHistorySuccess = true;
+                    } catch (fallbackError) { 
+                        logger.log('ERROR', `[handleUpdate/${userId}] History fetch direct fallback FAILED.`, { error: fallbackError.message, source: 'eToro/Network' });
+                        wasHistorySuccess = false; 
                     }
                 }
 
-                if (wasHistorySuccess) { logger.log('INFO', `[handleUpdate/${userId}] History fetch successful.`); // Some method worked, we are very smart
+                if (wasHistorySuccess) { 
+                    logger.log('INFO', `[handleUpdate/${userId}] History fetch successful.`);
                     const data = await response.json();
-                    await batchManager.addToTradingHistoryBatch(userId, portfolioBlockId, today, data, userType);  }
+                    await batchManager.addToTradingHistoryBatch(userId, portfolioBlockId, today, data, userType);  
+                }
             }
-        } else { logger.log('TRACE', `[handleUpdate/${userId}] History fetch skipped (already fetched by this instance).`); }
-    } catch (err) { logger.log('ERROR', `[handleUpdate/${userId}] Unhandled error during history processing.`, { error: err.message }); wasHistorySuccess = false; // We fucked up.
-    } finally { if (historyHeader && proxyUsedForHistory) { headerManager.updatePerformance(historyHeader.id, wasHistorySuccess); } } // If we used appscript proxy, record performance, otherwise fuck off.
+        } else { 
+            logger.log('TRACE', `[handleUpdate/${userId}] History fetch skipped (already fetched by this instance).`); 
+        }
+    } catch (err) { 
+        logger.log('ERROR', `[handleUpdate/${userId}] Unhandled error during history processing.`, { error: err.message }); 
+        wasHistorySuccess = false; 
+    } finally { 
+        if (historyHeader && proxyUsedForHistory) { headerManager.updatePerformance(historyHeader.id, wasHistorySuccess); } 
+    }
     
     // --- 2. Process Portfolio Fetches (Sequentially) ---
     logger.log('INFO', `[handleUpdate/${userId}] Starting ${instrumentsToProcess.length} sequential portfolio fetches.`);
     
-    for (const instId of instrumentsToProcess) { 
+    // Renamed loop variable to currentInstrumentId to prevent 'instId' reference errors later
+    for (const currentInstrumentId of instrumentsToProcess) { 
         if (isPrivate) { 
             logger.log('INFO', `[handleUpdate/${userId}] Skipping remaining instruments because user was marked as private.`); 
             break;  
         }
 
         const portfolioHeader = await headerManager.selectHeader();
-        if (!portfolioHeader) { logger.log('ERROR', `[handleUpdate/${userId}] Could not select portfolio header for instId ${instId}. Skipping this instrument.`);
+        if (!portfolioHeader) { 
+            logger.log('ERROR', `[handleUpdate/${userId}] Could not select portfolio header. Skipping instrument.`);
             continue;
         }
 
-        const portfolioUrl = userType === 'speculator'  ? `${config.ETORO_API_POSITIONS_URL}?cid=${userId}&InstrumentID=${instId}` : `${config.ETORO_API_PORTFOLIO_URL}?cid=${userId}`;
+        // Only append InstrumentID if it is defined (i.e., for speculators)
+        const portfolioUrl = userType === 'speculator' && currentInstrumentId 
+            ? `${config.ETORO_API_POSITIONS_URL}?cid=${userId}&InstrumentID=${currentInstrumentId}` 
+            : `${config.ETORO_API_PORTFOLIO_URL}?cid=${userId}`;
         
         const options = { headers: portfolioHeader.header };
         let response;
@@ -127,48 +175,54 @@ async function handleUpdate(task, taskId, { logger, headerManager, proxyManager,
         let proxyUsedForPortfolio = true;
 
         try {
-            // --- REFACTOR 3: ADD FALLBACK ---
-            logger.log('TRACE', `[handleUpdate/${userId}] Attempting portfolio fetch for instId ${instId} via AppScript proxy...`);
+            logger.log('TRACE', `[handleUpdate/${userId}] Attempting portfolio fetch via AppScript proxy...`);
             response = await proxyManager.fetch(portfolioUrl, options);
-            if (!response.ok) throw new Error(`AppScript proxy failed with status ${response.status}`); // SHIT we failed here
-            wasPortfolioSuccess = true; // Oh we are smart, worked first time.
+            if (!response.ok) throw new Error(`AppScript proxy failed with status ${response.status}`);
+            wasPortfolioSuccess = true;
 
-        } catch (proxyError) { // try fallback with local node fetch using GCP IP Pools
-            logger.log('WARN', `[handleUpdate/${userId}] Portfolio fetch for instId ${instId} via AppScript proxy FAILED. Error: ${proxyError.message}. Attempting direct node-fetch fallback.`, { error: proxyError.message, source: 'AppScript' });
-            proxyUsedForPortfolio = false; // We are not using Appscript proxy here as fallback is GCP based, so false
+        } catch (proxyError) { 
+            logger.log('WARN', `[handleUpdate/${userId}] Portfolio fetch via AppScript proxy FAILED. Error: ${proxyError.message}. Attempting direct node-fetch fallback.`, { error: proxyError.message, source: 'AppScript' });
+            proxyUsedForPortfolio = false; 
             
             try {
-                response = await fetch(portfolioUrl, options); // Direct node-fetch
+                response = await fetch(portfolioUrl, options);
                 if (!response.ok) {
                     const errorText = await response.text();
-                    throw new Error(`Direct fetch failed with status ${response.status}. Response: ${errorText.substring(0, 200)}`); // SHIT we failed here
+                    throw new Error(`Direct fetch failed with status ${response.status}. Response: ${errorText.substring(0, 200)}`);
                 }
-                wasPortfolioSuccess = true; // Fallback succeeded we are so smart
-                
+                wasPortfolioSuccess = true;
             } catch (fallbackError) {
-                logger.log('ERROR', `[handleUpdate/${userId}] Portfolio fetch for instId ${instId} direct fallback FAILED.`, { error: fallbackError.message, source: 'eToro/Network' });
+                logger.log('ERROR', `[handleUpdate/${userId}] Portfolio fetch direct fallback FAILED.`, { error: fallbackError.message, source: 'eToro/Network' });
                 wasPortfolioSuccess = false;
             }
         }
 
-        // --- 4. Process Portfolio Result (with verbose, raw logging) ---
         if (wasPortfolioSuccess) {
             const body = await response.text();
-            if (body.includes("user is PRIVATE")) { isPrivate = true; logger.log('WARN', `[handleUpdate/${userId}] User is PRIVATE. Marking for removal.`);
-                break; // Stop processing more portfolios for this private user
+            if (body.includes("user is PRIVATE")) { 
+                isPrivate = true; 
+                logger.log('WARN', `[handleUpdate/${userId}] User is PRIVATE. Marking for removal.`);
+                break; 
             }
 
             try {
                 const portfolioJson = JSON.parse(body);
-                await batchManager.addToPortfolioBatch(userId, portfolioBlockId, today, portfolioJson, userType, instId);
-                if (userType === 'speculator') { logger.log('INFO', `[handleUpdate/${userId}] Successfully processed portfolio for instId ${instId}.`); // Only speculators have an instid, so this is conditional
-                } else { logger.log('INFO', `[handleUpdate/${userId}] Successfully processed full portfolio (normal user).`); } // Normal users
+                // Pass currentInstrumentId to batchManager. For normal users it's undefined, which is fine.
+                await batchManager.addToPortfolioBatch(userId, portfolioBlockId, today, portfolioJson, userType, currentInstrumentId);
+                
+                if (userType === 'speculator') { 
+                    logger.log('INFO', `[handleUpdate/${userId}] Successfully processed portfolio for instId ${currentInstrumentId}.`); 
+                } else { 
+                    logger.log('INFO', `[handleUpdate/${userId}] Successfully processed full portfolio (normal user).`); 
+                }
 
-            } catch (parseError) { // Idk why this would happen, but if it does....log.
-                wasPortfolioSuccess = false; // Mark as failure
-                logger.log('ERROR', `[handleUpdate/${userId}] FAILED TO PARSE JSON RESPONSE. RAW BODY:`, { url: portfolioUrl, parseErrorMessage: parseError.message, rawResponseText: body }); // Return full response
+            } catch (parseError) { 
+                wasPortfolioSuccess = false; 
+                logger.log('ERROR', `[handleUpdate/${userId}] FAILED TO PARSE JSON RESPONSE. RAW BODY:`, { url: portfolioUrl, parseErrorMessage: parseError.message, rawResponseText: body }); 
             }
-        } else { logger.log('WARN', `[handleUpdate/${userId}] Portfolio fetch failed for instId ${instId}. No response to process.`); }
+        } else { 
+            logger.log('WARN', `[handleUpdate/${userId}] Portfolio fetch failed. No response to process.`); 
+        }
         
         if (proxyUsedForPortfolio) { headerManager.updatePerformance(portfolioHeader.id, wasPortfolioSuccess); }
     } 
@@ -176,21 +230,32 @@ async function handleUpdate(task, taskId, { logger, headerManager, proxyManager,
     // --- 5. Handle Private Users & Timestamps ---
     if (isPrivate) {
         logger.log('WARN', `[handleUpdate/${userId}] Removing private user from updates.`);
-        for (const instrumentId of instrumentsToProcess) { await batchManager.deleteFromTimestampBatch(userId, userType, instId); }
+        // Iterate again using correct scoping
+        for (const currentInstrumentId of instrumentsToProcess) { 
+            await batchManager.deleteFromTimestampBatch(userId, userType, currentInstrumentId); 
+        }
+        
         const blockCountsRef = db.doc(config.FIRESTORE_DOC_SPECULATOR_BLOCK_COUNTS);
-        for (const instrumentId of instrumentsToProcess) {
-            const incrementField = `counts.${instrumentId}_${Math.floor(userId/1e6)*1e6}`;
-            await blockCountsRef.set({ [incrementField]: FieldValue.increment(-1) }, { merge: true });
+        for (const currentInstrumentId of instrumentsToProcess) {
+            // Only update counts if we have a valid instrument ID (speculators)
+            if (currentInstrumentId) {
+                const incrementField = `counts.${currentInstrumentId}_${Math.floor(userId/1e6)*1e6}`;
+                await blockCountsRef.set({ [incrementField]: FieldValue.increment(-1) }, { merge: true });
+            }
         }
         return; 
     }
 
     // If not private, update all timestamps
-    for (const instrumentId of instrumentsToProcess) { await batchManager.updateUserTimestamp(userId, userType, instId); }
-    if (userType === 'speculator') { await batchManager.addSpeculatorTimestampFix(userId, String(Math.floor(userId/1e6)*1e6)); }
+    for (const currentInstrumentId of instrumentsToProcess) { 
+        await batchManager.updateUserTimestamp(userId, userType, currentInstrumentId); 
+    }
+    
+    if (userType === 'speculator') { 
+        await batchManager.addSpeculatorTimestampFix(userId, String(Math.floor(userId/1e6)*1e6)); 
+    }
     
     logger.log('INFO', `[handleUpdate/${userId}] Update task finished successfully.`);
-    // 'finally' block for header flushing is handled by the main handler_creator.js
 }
 
 module.exports = { handleUpdate, lookupUsernames };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.176",
+  "version": "1.0.178",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [