bulltrackers-module 1.0.170 → 1.0.172

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

@@ -15,87 +15,40 @@ async function lookupUsernames(cids, { logger, headerManager, proxyManager }, co
     if (!cids?.length) return [];
     logger.log('INFO', `[lookupUsernames] Looking up usernames for ${cids.length} CIDs.`);
     
-    // --- REFACTOR 1: REMOVE CONCURRENCY ---
+    // --- 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
     const limit = pLimit(1);
-    // --- END REFACTOR 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;
-        }
-        
+        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 {
-            // --- REFACTOR 3: ADD FALLBACK ---
             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;
+            wasSuccess = true; // Yay we win
             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'
-            });
-            
+        } 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); // Direct node-fetch
-                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'
-                });
+            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
             }
-            // --- END REFACTOR 3 ---
-        } 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); 
+        } 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; } }));
 
+    const results  = await Promise.allSettled(batchPromises);
+    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;
 }
@@ -110,8 +63,6 @@ async function handleUpdate(task, taskId, { logger, headerManager, proxyManager,
     const today = new Date().toISOString().slice(0, 10);
     const portfolioBlockId = `${Math.floor(parseInt(userId) / 1000000)}M`;
     let isPrivate = false;
-
-    // --- REFACTOR 2: ADD VERBOSE LOGGING (with User ID) ---
     logger.log('INFO', `[handleUpdate/${userId}] Starting update task. Type: ${userType}. Instruments: ${instrumentsToProcess.join(', ')}`);
 
     // --- 1. Process History Fetch (Sequentially) ---
@@ -123,81 +74,52 @@ 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 {
-                    // --- REFACTOR 3: ADD FALLBACK ---
-                    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}`);
-                    wasHistorySuccess = true;
+                    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
                     
                 } 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'
-                    });
+                    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
                     proxyUsedForHistory = false;
-
-                    try {
-                        response = await fetch(historyUrl, options); // Direct node-fetch
-                        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; // Fallback succeeded
+                    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'
-                        });
-                        wasHistorySuccess = false;
+                    } 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....
                     }
-                    // --- END REFACTOR 3 ---
                 }
 
-                if (wasHistorySuccess) {
-                    logger.log('INFO', `[handleUpdate/${userId}] History fetch successful.`);
+                if (wasHistorySuccess) { logger.log('INFO', `[handleUpdate/${userId}] History fetch successful.`); // Some method worked, we are very smart
                     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;
-    } finally {
-        if (historyHeader && proxyUsedForHistory) {
-            headerManager.updatePerformance(historyHeader.id, wasHistorySuccess);
-        }
-    }
+        } 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.
     
     // --- 2. Process Portfolio Fetches (Sequentially) ---
     logger.log('INFO', `[handleUpdate/${userId}] Starting ${instrumentsToProcess.length} sequential portfolio fetches.`);
     
-    for (const instId of instrumentsToProcess) {
-        if (isPrivate) {
-             logger.log('INFO', `[handleUpdate/${userId}] Skipping remaining instruments because user was marked as private.`);
-             break; 
+    for (const instId 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 for instId ${instId}. Skipping this instrument.`);
             continue;
         }
 
-        const portfolioUrl = userType === 'speculator' 
-            ? `${config.ETORO_API_POSITIONS_URL}?cid=${userId}&InstrumentID=${instId}`
-            : `${config.ETORO_API_PORTFOLIO_URL}?cid=${userId}`;
+        const portfolioUrl = userType === 'speculator'  ? `${config.ETORO_API_POSITIONS_URL}?cid=${userId}&InstrumentID=${instId}` : `${config.ETORO_API_PORTFOLIO_URL}?cid=${userId}`;
         
         const options = { headers: portfolioHeader.header };
         let response;
@@ -208,73 +130,53 @@ async function handleUpdate(task, taskId, { logger, headerManager, proxyManager,
             // --- REFACTOR 3: ADD FALLBACK ---
             logger.log('TRACE', `[handleUpdate/${userId}] Attempting portfolio fetch for instId ${instId} via AppScript proxy...`);
             response = await proxyManager.fetch(portfolioUrl, options);
-            if (!response.ok) throw new Error(`AppScript proxy failed with status ${response.status}`);
-            wasPortfolioSuccess = true;
+            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.
 
-        } catch (proxyError) {
-            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;
+        } 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
             
             try {
                 response = await fetch(portfolioUrl, options); // Direct node-fetch
                 if (!response.ok) {
                     const errorText = await response.text();
-                    throw new Error(`Direct fetch failed with status ${response.status}. Response: ${errorText.substring(0, 200)}`);
+                    throw new Error(`Direct fetch failed with status ${response.status}. Response: ${errorText.substring(0, 200)}`); // SHIT we failed here
                 }
-                wasPortfolioSuccess = true; // Fallback succeeded
+                wasPortfolioSuccess = true; // Fallback succeeded we are so smart
                 
             } 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 for instId ${instId} direct fallback FAILED.`, { error: fallbackError.message, source: 'eToro/Network' });
                 wasPortfolioSuccess = false;
             }
-            // --- END REFACTOR 3 ---
         }
 
         // --- 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.`);
+            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
             }
 
             try {
                 const portfolioJson = JSON.parse(body);
                 await batchManager.addToPortfolioBatch(userId, portfolioBlockId, today, portfolioJson, userType, instId);
-                logger.log('INFO', `[handleUpdate/${userId}] Successfully processed portfolio for instId ${instId}.`);
-                
-            } catch (parseError) {
-                // --- REFACTOR 4: RETURN EXACT PAGE RESPONSE ---
+                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
+
+            } 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 // <--- THIS LOGS THE FULL HTML/ERROR RESPONSE
-                });
-                // --- END REFACTOR 4 ---
+                logger.log('ERROR', `[handleUpdate/${userId}] FAILED TO PARSE JSON RESPONSE. RAW BODY:`, { url: portfolioUrl, parseErrorMessage: parseError.message, rawResponseText: body }); // Return full response
             }
-        } 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 for instId ${instId}. No response to process.`); }
         
-        if (proxyUsedForPortfolio) {
-            headerManager.updatePerformance(portfolioHeader.id, wasPortfolioSuccess);
-        }
-    } // --- End of sequential portfolio loop ---
+        if (proxyUsedForPortfolio) { headerManager.updatePerformance(portfolioHeader.id, wasPortfolioSuccess); }
+    } 
 
     // --- 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);
-        }
+        for (const instrumentId of instrumentsToProcess) { await batchManager.deleteFromTimestampBatch(userId, userType, instId); }
         const blockCountsRef = db.doc(config.FIRESTORE_DOC_SPECULATOR_BLOCK_COUNTS);
         for (const instrumentId of instrumentsToProcess) {
             const incrementField = `counts.${instrumentId}_${Math.floor(userId/1e6)*1e6}`;
@@ -284,12 +186,8 @@ async function handleUpdate(task, taskId, { logger, headerManager, proxyManager,
     }
 
     // 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 instrumentId of instrumentsToProcess) { await batchManager.updateUserTimestamp(userId, userType, instId); }
+    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

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

@@ -14,13 +14,10 @@ async function fetchAndVerifyUser(user, { logger, headerManager, proxyManager },
     const logPrefix = `[VERIFY/${taskId}/${cid}]`; // --- REFACTOR 2: VERBOSE LOGGING ---
 
     const selectedHeader = await headerManager.selectHeader();
-    if (!selectedHeader) {
-        logger.log('WARN', `${logPrefix} Could not select a header. Skipping user.`);
-        return null;
-    }
+    if (!selectedHeader) { logger.log('WARN', `${logPrefix} Could not select a header. Skipping user.`); return null; }
 
     let wasSuccess = false;
-    let proxyUsed = true;
+    let proxyUsed  = true;
             
     try { // Outer try for the whole operation
         let response;
@@ -30,30 +27,24 @@ async function fetchAndVerifyUser(user, { logger, headerManager, proxyManager },
         try {
             // --- REFACTOR 3: ADD FALLBACK ---
             logger.log('TRACE', `${logPrefix} Attempting portfolio fetch via AppScript proxy...`);
-            response = await proxyManager.fetch(url, options);
-            if (!response.ok) throw new Error(`AppScript proxy failed with status ${response.status}`);
+            response = await proxyManager.fetch(url, options); // Try....
+            if (!response.ok) throw new Error(`AppScript proxy failed with status ${response.status}`); // Fail
             
-        } catch (proxyError) {
-            logger.log('WARN', `${logPrefix} AppScript proxy fetch FAILED. Error: ${proxyError.message}. Attempting direct node-fetch fallback.`, {
-                error: proxyError.message,
-                source: 'AppScript'
-            });
+        } catch (proxyError) { // We fucked up, appscript proxy failed, log error type
+            logger.log('WARN', `${logPrefix} 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); // Direct node-fetch
-                if (!response.ok) {
+                response = await fetch(url, options); // Direct node-fetch as fallback
+                if (!response.ok) { // we fucked up here too, log error text
                     const errorText = await response.text();
                     throw new Error(`Direct fetch failed with status ${response.status}. Response: ${errorText.substring(0, 200)}`);
                 }
                 // Fallback succeeded, but we don't set wasSuccess yet,
                 // as we still need to parse the body.
                 
-            } catch (fallbackError) {
-                logger.log('ERROR', `${logPrefix} Direct node-fetch fallback FAILED.`, {
-                    error: fallbackError.message,
-                    source: 'eToro/Network'
-                });
+            } catch (fallbackError) { // log error type for fallback
+                logger.log('ERROR', `${logPrefix} Direct node-fetch fallback FAILED.`, { error: fallbackError.message, source: 'eToro/Network' });
                 throw fallbackError; // Throw to be caught by outer try
             }
             // --- END REFACTOR 3 ---
@@ -62,46 +53,38 @@ async function fetchAndVerifyUser(user, { logger, headerManager, proxyManager },
         // --- If we are here, `response` is valid ---
         let portfolioData;
         const body = await response.text();
-        
-        try {
-            // --- REFACTOR 4: LOG RAW RESPONSE ON PARSE FAILURE ---
-            portfolioData = JSON.parse(body);
-        } catch (parseError) {
-            logger.log('ERROR', `${logPrefix} FAILED TO PARSE JSON RESPONSE. RAW BODY:`, {
-                parseErrorMessage: parseError.message,
-                rawResponseText: body 
-            });
+        // --- REFACTOR 4: LOG RAW RESPONSE ON PARSE FAILURE ---
+        try { portfolioData = JSON.parse(body);
+        } catch (parseError) { // If we can't parse JSON, try raw log, shouldn't happen but this world is weird....
+            logger.log('ERROR', `${logPrefix} FAILED TO PARSE JSON RESPONSE. RAW BODY:`, { parseErrorMessage: parseError.message, rawResponseText: body  });
             throw new Error(`Failed to parse JSON for user ${cid}.`);
         }
         // --- END REFACTOR 4 ---
 
         // --- Original logic ---
         if (userType === 'speculator') {
-            const instruments = portfolioData.AggregatedPositions.map(p => p.InstrumentID).filter(id => SPECULATOR_INSTRUMENTS_ARRAY.includes(id));
+            const instruments = portfolioData.AggregatedPositions.map(p => p.InstrumentID).filter(id => SPECULATOR_INSTRUMENTS_ARRAY.includes(id)); 
             if (!instruments.length) {
                 logger.log('TRACE', `${logPrefix} Verified user, but not a speculator (no matching assets).`);
-                wasSuccess = true; // API call *worked*
+                wasSuccess = true; // API call *worked* we are so smart
                 return null;
             }
-            logger.log('INFO', `${logPrefix} Verified as SPECULATOR.`);
-            wasSuccess = true;
-            return { type: 'speculator', userId: cid, isBronze: user.isBronze, username: user.username, updateData: { instruments, lastVerified: new Date(), lastHeldSpeculatorAsset: new Date() } };
+            logger.log('INFO', `${logPrefix} Verified as SPECULATOR.`); 
+            wasSuccess = true; // Mark that we are very high IQ
+            return { type: 'speculator', userId: cid, isBronze: user.isBronze, username: user.username, updateData: { instruments, lastVerified: new Date(), lastHeldSpeculatorAsset: new Date() } }; // Return values
         }
-
-        logger.log('INFO', `${logPrefix} Verified as NORMAL user.`);
-        wasSuccess = true;
-        return { type: 'normal', userId: cid, isBronze: user.isBronze, username: user.username, updateData: { lastVerified: new Date() } };
+        // Other user types are just normal users....
+        logger.log('INFO', `${logPrefix} Verified as NORMAL user.`); 
+        wasSuccess = true; // We are smart, this worked
+        return { type: 'normal', userId: cid, isBronze: user.isBronze, username: user.username, updateData: { lastVerified: new Date() } }; // Return values 
         
     } catch (err) {
         // This catches proxy, fallback, or parse errors
-        logger.log('WARN', `${logPrefix} Error processing user.`, { errorMessage: err.message });
+        logger.log('WARN', `${logPrefix} Error processing user.`, { errorMessage: err.message }); // Some shit broke
         wasSuccess = false; // Ensure it's marked as failure
         return null;
     } finally {
-        if (selectedHeader && proxyUsed) {
-            // Only update performance if the proxy was used
-            headerManager.updatePerformance(selectedHeader.id, wasSuccess);
-        }
+        if (selectedHeader && proxyUsed) { headerManager.updatePerformance(selectedHeader.id, wasSuccess); } // Only update performance if the proxy was used
     }
 }
 
@@ -118,7 +101,7 @@ async function handleVerify(task, taskId, { db, logger, ...dependencies }, confi
     logger.log('INFO', `[VERIFY/${taskId}] Starting sequential verification for ${users.length} users...`);
     const results = [];
     for (const user of users) {
-        // Await each user one by one
+        // Await each user one by one otherwise appscript starts to cry and internally throttle...then rate limit...then fuck everything up and break and then i want to die.
         const result = await fetchAndVerifyUser(user, { db, logger, ...dependencies }, { ...config, userType }, taskId);
         results.push(result); // Push the actual result (or null)
     }
@@ -136,7 +119,7 @@ async function handleVerify(task, taskId, { db, logger, ...dependencies }, confi
             else normalUpdates[`users.${d.userId}`] = d.updateData; 
         }
     });
-
+    // Process responses in object keys
     if (Object.keys(speculatorUpdates).length || Object.keys(normalUpdates).length) {
         const blockRef = db.collection(userType === 'speculator' ? config.FIRESTORE_COLLECTION_SPECULATOR_BLOCKS : config.FIRESTORE_COLLECTION_NORMAL_PORTFOLIOS).doc(String(blockId));
         batch.set(blockRef, userType === 'speculator' ? speculatorUpdates : normalUpdates, { merge: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.170",
+  "version": "1.0.172",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [
@@ -27,10 +27,6 @@
     "calculations",
     "finance"
   ],
-  "scripts": {
-    "postpublish": "node ./auto-deploy.js",
-    "release": "node ./release.js"
-  },
   "dependencies": {
     "@google-cloud/firestore": "^7.11.3",
     "@google-cloud/pubsub": "latest",