bulltrackers-module 1.0.127 → 1.0.129

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

@@ -1,6 +1,6 @@
 /*
  * FILENAME: CloudFunctions/NpmWrappers/bulltrackers-module/functions/task-engine/helpers/update_helpers.js
- * (FIXED: Enhanced error logging for portfolio and history fetches)
+ * (MODIFIED: To conditionally fetch history API once per user per batch)
  */
 
 /**
@@ -9,227 +9,132 @@
  * OPTIMIZED: Removed immediate batch commit for speculator timestamp fix.
  * --- MODIFIED: Fetches portfolio AND trade history in parallel. ---
  * --- MODIFIED: Includes helper to look up usernames from CIDs. ---
+ * --- MODIFIED: Conditionally fetches history only once per user per batch. ---
  */
 const { FieldValue } = require('@google-cloud/firestore');
 
-/**
- * --- NEW HELPER ---
- * Fetches user details (including username) from the rankings API for a batch of CIDs.
- * @param {Array<string>} cids - An array of user CIDs (as strings or numbers).
- * @param {object} dependencies - Contains proxyManager, headerManager, logger.
- * @param {object} config - The configuration object.
- * @returns {Promise<Array<object>>} An array of the raw user objects from the API.
- */
-async function lookupUsernames(cids, dependencies, config) {
-    const { logger, headerManager, proxyManager } = dependencies;
-    const { USERNAME_LOOKUP_BATCH_SIZE, ETORO_API_RANKINGS_URL } = config;
-
-    if (!cids || cids.length === 0) {
-        return [];
-    }
-
+async function lookupUsernames(cids, { logger, headerManager, proxyManager }, { USERNAME_LOOKUP_BATCH_SIZE, ETORO_API_RANKINGS_URL }) {
+    if (!cids?.length) return [];
     logger.log('INFO', `[lookupUsernames] Looking up usernames for ${cids.length} CIDs.`);
-    const allPublicUsers = [];
-
+    const allUsers = [];
     for (let i = 0; i < cids.length; i += USERNAME_LOOKUP_BATCH_SIZE) {
-        const batchCids = cids.slice(i, i + USERNAME_LOOKUP_BATCH_SIZE).map(Number);
-        
-        const url = `${ETORO_API_RANKINGS_URL}?Period=LastTwoYears`;
-        const selectedHeader = await headerManager.selectHeader();
-        if (!selectedHeader) {
-            logger.log('ERROR', '[lookupUsernames] Could not select a header.');
-            continue; // Skip this batch
-        }
-
-        let wasSuccess = false;
+        const batch = cids.slice(i, i + USERNAME_LOOKUP_BATCH_SIZE).map(Number);
+        const header = await headerManager.selectHeader();
+        if (!header) { logger.log('ERROR', '[lookupUsernames] Could not select a header.'); continue; }
+        let success = false;
         try {
-            const response = await proxyManager.fetch(url, {
-                method: 'POST',
-                headers: { ...selectedHeader.header, 'Content-Type': 'application/json' },
-                body: JSON.stringify(batchCids),
+            const res = await proxyManager.fetch(`${ETORO_API_RANKINGS_URL}?Period=LastTwoYears`, {
+                method: 'POST', headers: { ...header.header, 'Content-Type': 'application/json' }, body: JSON.stringify(batch)
             });
-
-            if (!response.ok) {
-                throw new Error(`[lookupUsernames] API status ${response.status}`);
-            }
-            wasSuccess = true;
-
-            const publicUsers = await response.json();
-            if (Array.isArray(publicUsers)) {
-                allPublicUsers.push(...publicUsers);
-            }
-        } catch (error) {
-            logger.log('WARN', `[lookupUsernames] Failed to fetch batch of usernames.`, { errorMessage: error.message });
-        } finally {
-            if (selectedHeader) {
-                headerManager.updatePerformance(selectedHeader.id, wasSuccess);
-            }
-        }
+            if (!res.ok) throw new Error(`API status ${res.status}`);
+            const data = await res.json();
+            if (Array.isArray(data)) allUsers.push(...data);
+            success = true;
+        } catch (err) {
+            logger.log('WARN', `[lookupUsernames] Failed batch`, { error: err.message });
+        } finally { headerManager.updatePerformance(header.id, success); }
     }
-
-    logger.log('INFO', `[lookupUsernames] Found ${allPublicUsers.length} public users out of ${cids.length}.`);
-    return allPublicUsers;
+    logger.log('INFO', `[lookupUsernames] Found ${allUsers.length} public users out of ${cids.length}.`);
+    return allUsers;
 }
 
+// --- START MODIFICATION: Added historyFetchedForUser argument ---
+async function handleUpdate(task, taskId, { logger, headerManager, proxyManager, db, batchManager }, config, username, historyFetchedForUser) {
+// --- END MODIFICATION ---
 
-/**
- * Sub-pipe: pipe.taskEngine.handleUpdate
- * @param {object} task The Pub/Sub task payload.
- * @param {string} taskId A unique ID for logging.
- * @param {object} dependencies - Contains db, pubsub, logger, headerManager, proxyManager, batchManager.
- * @param {object} config The configuration object.
- * @param {string} username - The user's eToro username.
- */
-async function handleUpdate(task, taskId, dependencies, config, username) {
-    const { logger, headerManager, proxyManager, db, batchManager } = dependencies;
     const { userId, instrumentId, userType } = task;
-
-    // --- START MODIFICATION: Define both URLs ---
-    const portfolioUrl = userType === 'speculator' 
-        ? `${config.ETORO_API_POSITIONS_URL}?cid=${userId}&InstrumentID=${instrumentId}` 
+    const portfolioUrl = userType === 'speculator'
+        ? `${config.ETORO_API_POSITIONS_URL}?cid=${userId}&InstrumentID=${instrumentId}`
         : `${config.ETORO_API_PORTFOLIO_URL}?cid=${userId}`;
-
-    const historyUrl = `${config.ETORO_API_USERSTATS_URL}${username}/trades/oneYearAgo?CopyAsAsset=true`;
     
+    // --- MODIFICATION: Moved historyUrl definition inside conditional ---
     const today = new Date().toISOString().slice(0, 10);
-    const portfolioStorageBlockId = `${Math.floor(parseInt(userId) / 1000000)}M`;
-    
-    let portfolioHeader = null;
-    let historyHeader = null;
-    let wasPortfolioSuccess = false;
-    let wasHistorySuccess = false;
-    let isPrivate = false;
+    const portfolioBlockId = `${Math.floor(parseInt(userId) / 1000000)}M`;
 
-    try {
-        logger.log('INFO', `[UPDATE] Fetching data for user ${userId} (${username}, ${userType})`);
+    // --- MODIFICATION: Select history header only if needed ---
+    let portfolioHeader = await headerManager.selectHeader();
+    let historyHeader = null; // Will be selected if needed
+    if (!portfolioHeader) throw new Error("Could not select portfolio header.");
 
-        // Select headers for both requests
-        portfolioHeader = await headerManager.selectHeader();
-        historyHeader = await headerManager.selectHeader();
-        if (!portfolioHeader || !historyHeader) {
-            throw new Error("Could not select headers for update requests.");
-        }
+    let wasPortfolioSuccess = false, wasHistorySuccess = false, isPrivate = false;
 
-        // --- Fetch both endpoints in parallel ---
-        const [portfolioResult, historyResult] = await Promise.allSettled([
-            proxyManager.fetch(portfolioUrl, { headers: portfolioHeader.header }),
-            proxyManager.fetch(historyUrl, { headers: historyHeader.header })
-        ]);
-
-        // --- Process Portfolio Result ---
-        if (portfolioResult.status === 'fulfilled' && portfolioResult.value.ok) {
-            const responseBody = await portfolioResult.value.text();
-            
-            // Check for private user
-            if (responseBody.includes("user is PRIVATE")) {
-                isPrivate = true;
+    try {
+        // --- START MODIFICATION: Build promises conditionally ---
+        const promisesToRun = [];
+
+        // 1. Always fetch portfolio
+        promisesToRun.push(proxyManager.fetch(portfolioUrl, { headers: portfolioHeader.header }));
+
+        // 2. Conditionally fetch history
+        let fetchHistory = false;
+        if (!historyFetchedForUser.has(userId)) {
+            historyHeader = await headerManager.selectHeader(); // Select header just-in-time
+            if (!historyHeader) {
+                logger.log('WARN', `[UPDATE] Could not select history header for ${userId}, skipping history fetch for this batch.`);
+                historyFetchedForUser.add(userId); // Add to set to prevent retries in this batch
             } else {
-                wasPortfolioSuccess = true;
-                const portfolioData = JSON.parse(responseBody);
-                // Add to portfolio batch
-                console.log('DEBUG', `[UPDATE] SUCCESS Adding portfolio data for user ${userId} to batch.`);
-                await batchManager.addToPortfolioBatch(userId, portfolioStorageBlockId, today, portfolioData, userType, instrumentId);
-                
+                fetchHistory = true;
+                historyFetchedForUser.add(userId); // Mark as fetched for this batch
+                const historyUrl = `${config.ETORO_API_USERSTATS_URL}${username}/trades/oneYearAgo?CopyAsAsset=true`;
+                promisesToRun.push(proxyManager.fetch(historyUrl, { headers: historyHeader.header }));
             }
+        }
+        // --- END MODIFICATION ---
+
+        // --- Run Promises ---
+        const results = await Promise.allSettled(promisesToRun);
+        const portfolioRes = results[0];
+        const historyRes = fetchHistory ? results[1] : null; // History is only index 1 if we fetched it
+
+        // --- Process Portfolio (results[0]) ---
+        if (portfolioRes.status === 'fulfilled' && portfolioRes.value.ok) {
+            const body = await portfolioRes.value.text();
+            if (body.includes("user is PRIVATE")) isPrivate = true;
+            else { wasPortfolioSuccess = true; await batchManager.addToPortfolioBatch(userId, portfolioBlockId, today, JSON.parse(body), userType, instrumentId); }
         } else {
-            // --- FIX: ENHANCED LOGGING ---
-            let errorMsg = 'Unknown fetch error';
-            let rawErrorText = 'N/A';
-
-            if (portfolioResult.status === 'rejected') {
-                errorMsg = portfolioResult.reason.message;
-            } else if (portfolioResult.value) {
-                errorMsg = portfolioResult.value.error?.message || `API status ${portfolioResult.value.status}`;
-                // Get the raw text from the proxy manager's response
-                if (typeof portfolioResult.value.text === 'function') {
-                    rawErrorText = await portfolioResult.value.text();
-                }
-            }
-            
-            logger.log('WARN', `[UPDATE] Failed to fetch PORTFOLIO for user ${userId}.`, { 
-                error: errorMsg,
-                proxyResponse: rawErrorText // This will contain "urlfetch" or other quota messages
-            });
-            // --- END FIX ---
+            let errMsg = portfolioRes.status === 'rejected' ? portfolioRes.reason.message : `API status ${portfolioRes.value.status}`;
+            let rawText = portfolioRes.value?.text ? await portfolioRes.value.text() : 'N/A';
+            logger.log('WARN', `[UPDATE] Portfolio fetch failed for ${userId}`, { error: errMsg, proxyResponse: rawText });
         }
 
-        // --- Process History Result ---
-        if (historyResult.status === 'fulfilled' && historyResult.value.ok) {
-            const historyData = await historyResult.value.json();
-            wasHistorySuccess = true;
-            // Add to history batch
-            console.log('DEBUG', `[UPDATE] SUCCESS Adding history data for user ${userId} to batch.`);
-            await batchManager.addToTradingHistoryBatch(userId, portfolioStorageBlockId, today, historyData, userType);
-        } else {
-            // --- FIX: ENHANCED LOGGING ---
-            let errorMsg = 'Unknown fetch error';
-            let rawErrorText = 'N/A';
-
-            if (historyResult.status === 'rejected') {
-                errorMsg = historyResult.reason.message;
-            } else if (historyResult.value) {
-                errorMsg = historyResult.value.error?.message || `API status ${historyResult.value.status}`;
-                // Get the raw text from the proxy manager's response
-                if (typeof historyResult.value.text === 'function') {
-                    rawErrorText = await historyResult.value.text();
-                }
+        // --- Process History (results[1], if it exists) ---
+        if (fetchHistory && historyRes) { // Check if we ran this promise
+            if (historyRes.status === 'fulfilled' && historyRes.value.ok) {
+                const data = await historyRes.value.json();
+                wasHistorySuccess = true; 
+                await batchManager.addToTradingHistoryBatch(userId, portfolioBlockId, today, data, userType);
+            } else {
+                // History fetch failed
+                let errMsg = historyRes.status === 'rejected' ? historyRes.reason.message : `API status ${historyRes.value.status}`;
+                let rawText = historyRes.value?.text ? await historyRes.value.text() : 'N/A';
+                logger.log('WARN', `[UPDATE] History fetch failed for ${userId} (${username})`, { error: errMsg, proxyResponse: rawText });
             }
-            
-            logger.log('WARN', `[UPDATE] Failed to fetch HISTORY for user ${userId} (${username}).`, { 
-                error: errorMsg,
-                proxyResponse: rawErrorText // This will contain "urlfetch" or other quota messages
-            });
-            // --- END FIX ---
         }
+        // --- END MODIFICATION ---
 
-        // --- Handle Private User (if detected) ---
-        if (isPrivate) {
-            logger.log('WARN', `User ${userId} is private. Removing from future updates and decrementing block count.`);
-            batchManager.deleteFromTimestampBatch(userId, userType, instrumentId);
 
-            let blockId;
-            let incrementField;
+        // --- Private user handling ---
+        if (isPrivate) {
+            logger.log('WARN', `User ${userId} is private. Removing from updates.`);
+            await batchManager.deleteFromTimestampBatch(userId, userType, instrumentId);
 
-            if (userType === 'speculator') {
-                blockId = String(Math.floor(parseInt(userId) / 1000000) * 1000000);
-                incrementField = `counts.${instrumentId}_${blockId}`;
-            } else {
-                blockId = String(Math.floor(parseInt(userId) / 1000000) * 1000000);
-                incrementField = `counts.${blockId}`;
-            }
-            
-            const blockCountsRef = db.doc(userType === 'speculator' 
-                ? config.FIRESTORE_DOC_SPECULATOR_BLOCK_COUNTS 
-                : config.FIRESTORE_DOC_BLOCK_COUNTS);
-                
-            // This is a single, immediate write, which is fine for this rare case.
-            // We use .set here because batchManager.flushBatches() might not run if this is the only user.
-            // To be safer, this should also be added to a batch, but this is an edge case.
+            const blockCountsRef = db.doc(userType === 'speculator' ? config.FIRESTORE_DOC_SPECULATOR_BLOCK_COUNTS : config.FIRESTORE_DOC_BLOCK_COUNTS);
+            const incrementField = userType === 'speculator' ? `counts.${instrumentId}_${Math.floor(userId/1e6)*1e6}` : `counts.${Math.floor(userId/1e6)*1e6}`;
             await blockCountsRef.set({ [incrementField]: FieldValue.increment(-1) }, { merge: true });
             return;
         }
 
-        // --- If either fetch was successful, update timestamps ---
         if (wasPortfolioSuccess || wasHistorySuccess) {
-            // This call is correct for 'normal' users.
             await batchManager.updateUserTimestamp(userId, userType, instrumentId);
-
-            // This is the fix for speculator timestamps
-            if (userType === 'speculator') {
-                const orchestratorBlockId = String(Math.floor(parseInt(userId) / 1000000) * 1000000);
-                logger.log('INFO', `[UPDATE] Applying speculator timestamp fix for user ${userId} in block ${orchestratorBlockId}`);
-                await batchManager.addSpeculatorTimestampFix(userId, orchestratorBlockId);
-            }
+            if (userType === 'speculator') await batchManager.addSpeculatorTimestampFix(userId, String(Math.floor(userId/1e6)*1e6));
         }
-        
     } finally {
-        // Update performance for both headers used
         if (portfolioHeader) headerManager.updatePerformance(portfolioHeader.id, wasPortfolioSuccess);
-        if (historyHeader) headerManager.updatePerformance(historyHeader.id, wasHistorySuccess);
+        
+        // --- MODIFICATION: Only update history header if we used it ---
+        if (fetchHistory && historyHeader) headerManager.updatePerformance(historyHeader.id, wasHistorySuccess);
+        // --- END MODIFICATION ---
     }
 }
 
-module.exports = { 
-    handleUpdate,
-    lookupUsernames // <-- EXPORT NEW HELPER
-};
+module.exports = { handleUpdate, lookupUsernames };

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

@@ -1,188 +1,72 @@
-/**
- * @fileoverview Sub-pipe: pipe.taskEngine.handleVerify
- * REFACTORED: Now stateless and receives dependencies.
- * OPTIMIZED: Fetches all user portfolios in parallel to reduce function runtime.
- * --- MODIFIED: Saves username to cid_username_map collection. ---
- */
 const { FieldValue } = require('@google-cloud/firestore');
 
-/**
- * Internal helper to fetch and process a single user's portfolio.
- * @param {object} user - The user object { cid, isBronze, username }
- * @param {object} dependencies - Contains proxyManager, headerManager
- * @param {object} config - The configuration object
- * @param {Set<number>} speculatorInstrumentSet - Pre-built Set of instrument IDs
- * @returns {Promise<object|null>} A result object for batching, or null on failure.
- */
-async function fetchAndVerifyUser(user, dependencies, config, speculatorInstrumentSet) {
-    const { logger, headerManager, proxyManager } = dependencies;
-    const userId = user.cid;
-    
-    const portfolioUrl = `${config.ETORO_API_PORTFOLIO_URL}?cid=${userId}`;
+async function fetchAndVerifyUser(user, { logger, headerManager, proxyManager }, { userType, SPECULATOR_INSTRUMENTS_ARRAY }) {
     const selectedHeader = await headerManager.selectHeader();
-    if (!selectedHeader) return null; // Cannot fetch
+    if (!selectedHeader) return null;
 
     let wasSuccess = false;
     try {
-        const response = await proxyManager.fetch(portfolioUrl, { headers: selectedHeader.header });
-        if (!response.ok) {
-            wasSuccess = false;
-            return null; // API error or private user
-        }
-        wasSuccess = true;
-        
-        const portfolioData = await response.json();
-
-        // Process verification logic *within* the parallel task
-        if (config.userType === 'speculator') {
-            const matchingInstruments = portfolioData.AggregatedPositions
-                .map(p => p.InstrumentID)
-                .filter(id => speculatorInstrumentSet.has(id));
+        const res = await proxyManager.fetch(`${process.env.ETORO_API_PORTFOLIO_URL}?cid=${user.cid}`, { headers: selectedHeader.header });
+        if (!res.ok) return null;
 
-            if (matchingInstruments.length > 0) {
-                logger.log('INFO', `[VERIFY] Speculator user ${userId} holds assets: ${matchingInstruments.join(', ')}`);
-                // Return data needed for the speculator batch update
-                return {
-                    type: 'speculator',
-                    userId: userId,
-                    isBronze: user.isBronze,
-                    username: user.username, // <-- PASS USERNAME
-                    updateData: {
-                        instruments: matchingInstruments,
-                        lastVerified: new Date(),
-                        lastHeldSpeculatorAsset: new Date()
-                    }
-                };
-            } else {
-                 logger.log('INFO', `[VERIFY] Speculator user ${userId} does not hold any speculator assets.`);
-                 return null; // Valid fetch, but failed verification
-            }
-        } else { // Normal user verification
-            // Return data needed for the normal user batch update
-            return {
-                type: 'normal',
-                userId: userId,
-                isBronze: user.isBronze,
-                username: user.username, // <-- PASS USERNAME
-                updateData: {
-                    lastVerified: new Date()
-                }
-            };
+        wasSuccess = true;
+        const portfolioData = await res.json();
+        if (userType === 'speculator') {
+            const instruments = portfolioData.AggregatedPositions.map(p => p.InstrumentID)
+                                .filter(id => SPECULATOR_INSTRUMENTS_ARRAY.includes(id));
+            if (!instruments.length) return null;
+            return { type: 'speculator', userId: user.cid, isBronze: user.isBronze, username: user.username, updateData: { instruments, lastVerified: new Date(), lastHeldSpeculatorAsset: new Date() } };
         }
-    } catch (error) {
-        logger.log('WARN', `[VERIFY] Error processing user ${userId}`, { errorMessage: error.message });
+        return { type: 'normal', userId: user.cid, isBronze: user.isBronze, username: user.username, updateData: { lastVerified: new Date() } };
+    } catch (err) {
+        logger.log('WARN', `[VERIFY] Error processing user ${user.cid}`, { errorMessage: err.message });
         return null;
     } finally {
         if (selectedHeader) headerManager.updatePerformance(selectedHeader.id, wasSuccess);
     }
 }
 
-
-/**
- * Sub-pipe: pipe.taskEngine.handleVerify
- * @param {object} task The Pub/Sub task payload.
- * @param {string} taskId A unique ID for logging.
- * @param {object} dependencies - Contains db, pubsub, logger, headerManager, proxyManager, batchManager.
- * @param {object} config The configuration object.
- */
-async function handleVerify(task, taskId, dependencies, config) {
-    const { logger, db } = dependencies;
+async function handleVerify(task, taskId, { db, logger, ...dependencies }, config) {
     const { users, blockId, instrument, userType } = task;
-    
-    // Use db from dependencies
     const batch = db.batch();
-    let validUserCount = 0;
-    const speculatorUpdates = {};
-    const normalUserUpdates = {};
-    const bronzeStateUpdates = {}; // This can be one object
-    
-    // --- NEW: Object to store username updates ---
-    const usernameMapUpdates = {};
-    // --- END NEW ---
-
-    const speculatorInstrumentSet = new Set(config.SPECULATOR_INSTRUMENTS_ARRAY);
-    
-    // --- OPTIMIZATION: Run all user fetches in parallel ---
-    const verificationPromises = users.map(user => 
-        fetchAndVerifyUser(
-            user, 
-            dependencies, 
-            { ...config, userType: userType }, // Pass userType into the helper config
-            speculatorInstrumentSet
-        )
-    );
-
-    const results = await Promise.allSettled(verificationPromises);
-    // --- END OPTIMIZATION ---
-
-    // Process results (this is fast, no I/O)
-    results.forEach(result => {
-        if (result.status === 'rejected' || !result.value) {
-            // Log rejection reason if needed: result.reason
-            return;
-        }
+    const speculatorUpdates = {}, normalUpdates = {}, bronzeStates = {}, usernameMap = {};
+    const specSet = new Set(config.SPECULATOR_INSTRUMENTS_ARRAY);
 
-        const data = result.value;
-        
-        // --- NEW: Capture username ---
-        if (data.username) {
-            // We use the CID as the key for the username map
-            usernameMapUpdates[data.userId] = { username: data.username };
-        }
-        // --- END NEW ---
+    const results = await Promise.allSettled(users.map(u => fetchAndVerifyUser(u, dependencies, { ...config, userType })));
 
-        if (data.type === 'speculator') {
-            speculatorUpdates[`users.${data.userId}`] = data.updateData;
-            bronzeStateUpdates[data.userId] = data.isBronze;
-            validUserCount++;
-        } else if (data.type === 'normal') {
-            normalUserUpdates[`users.${data.userId}`] = data.updateData;
-            bronzeStateUpdates[data.userId] = data.isBronze;
+    let validUserCount = 0;
+    results.forEach(r => {
+        if (r.status === 'fulfilled' && r.value) {
+            const d = r.value;
+            usernameMap[d.userId] = { username: d.username };
+            bronzeStates[d.userId] = d.isBronze;
             validUserCount++;
+            if (d.type === 'speculator') speculatorUpdates[`users.${d.userId}`] = d.updateData;
+            else normalUpdates[`users.${d.userId}`] = d.updateData;
         }
     });
 
+    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 });
+        const bronzeRef = db.collection(userType === 'speculator' ? config.FIRESTORE_COLLECTION_BRONZE_SPECULATORS : config.FIRESTORE_COLLECTION_BRONZE_NORMAL).doc(String(blockId));
+        batch.set(bronzeRef, bronzeStates, { merge: true });
 
-    if (Object.keys(speculatorUpdates).length > 0 || Object.keys(normalUserUpdates).length > 0) {
-        if (userType === 'speculator') {
-            const speculatorBlockRef = db.collection(config.FIRESTORE_COLLECTION_SPECULATOR_BLOCKS).doc(String(blockId));
-            batch.set(speculatorBlockRef, speculatorUpdates, { merge: true });
-            const bronzeStateRef = db.collection(config.FIRESTORE_COLLECTION_BRONZE_SPECULATORS).doc(String(blockId));
-            batch.set(bronzeStateRef, bronzeStateUpdates, {merge: true});
-
-        } else {
-            const normalBlockRef = db.collection(config.FIRESTORE_COLLECTION_NORMAL_PORTFOLIOS).doc(String(blockId));
-            batch.set(normalBlockRef, normalUserUpdates, { merge: true });
-            const bronzeStateRef = db.collection(config.FIRESTORE_COLLECTION_BRONZE_NORMAL).doc(String(blockId));
-            batch.set(bronzeStateRef, bronzeStateUpdates, {merge: true});
-        }
-        
-        if (validUserCount > 0) {
-            const blockCountsRef = db.doc(userType === 'speculator' 
-                ? config.FIRESTORE_DOC_SPECULATOR_BLOCK_COUNTS 
-                : config.FIRESTORE_DOC_BLOCK_COUNTS);
-            
-            const incrementField = userType === 'speculator' ? `counts.${instrument}_${blockId}` : `counts.${blockId}`;
-            batch.set(blockCountsRef, { [incrementField]: FieldValue.increment(validUserCount) }, { merge: true });
+        if (validUserCount) {
+            const countsRef = db.doc(userType === 'speculator' ? config.FIRESTORE_DOC_SPECULATOR_BLOCK_COUNTS : config.FIRESTORE_DOC_BLOCK_COUNTS);
+            const field = userType === 'speculator' ? `counts.${instrument}_${blockId}` : `counts.${blockId}`;
+            batch.set(countsRef, { [field]: FieldValue.increment(validUserCount) }, { merge: true });
         }
     }
-    
-    // --- NEW: Add username map updates to the batch ---
-    // We will use a simple sharding strategy (e.g., by first letter of CID)
-    // For simplicity here, we'll write to one document.
-    // A better production strategy would shard.
-    if (Object.keys(usernameMapUpdates).length > 0) {
-        // Simple, non-scalable approach:
-        const mapDocRef = db.collection(config.FIRESTORE_COLLECTION_USERNAME_MAP).doc('cid_map_shard_1');
-        batch.set(mapDocRef, usernameMapUpdates, { merge: true });
-        logger.log('INFO', `[VERIFY] Staging ${Object.keys(usernameMapUpdates).length} username updates.`);
+
+    if (Object.keys(usernameMap).length) {
+        const mapRef = db.collection(config.FIRESTORE_COLLECTION_USERNAME_MAP).doc('cid_map_shard_1');
+        batch.set(mapRef, usernameMap, { merge: true });
+        logger.log('INFO', `[VERIFY] Staging ${Object.keys(usernameMap).length} username updates.`);
     }
-    // --- END NEW ---
-    
+
     await batch.commit();
-    if(validUserCount > 0) {
-        logger.log('INFO', `[VERIFY] Verified and stored ${validUserCount} new ${userType} users.`);
-    }
+    if (validUserCount) logger.log('INFO', `[VERIFY] Verified and stored ${validUserCount} new ${userType} users.`);
 }
 
-module.exports = { handleVerify };
+module.exports = { handleVerify };