@defillama/sdk 5.0.185 → 5.0.188

package/build/util/indexer.js

@@ -11,20 +11,27 @@ exports.getTransactions = getTransactions;
 exports.isIndexerEnabled = isIndexerEnabled;
 exports.isIndexer2Enabled = isIndexer2Enabled;
 const axios_1 = __importDefault(require("axios"));
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const stream_json_1 = require("stream-json");
+const Pick_1 = require("stream-json/filters/Pick");
+const StreamArray_1 = require("stream-json/streamers/StreamArray");
 const _1 = require(".");
 const general_1 = require("../general");
-const common_1 = require("./common");
 const blocks_1 = require("./blocks");
 const cache_1 = require("./cache");
+const common_1 = require("./common");
 const debugLog_1 = require("./debugLog");
 const env_1 = require("./env");
 const logs_1 = require("./logs");
+const logs_decode_shared_1 = require("./logs.decode.shared");
 const indexerURL = (0, env_1.getEnvValue)("LLAMA_INDEXER_ENDPOINT");
 const LLAMA_INDEXER_API_KEY = (0, env_1.getEnvValue)("LLAMA_INDEXER_API_KEY");
 const LLAMA_INDEXER_V2_ENDPOINT = (0, env_1.getEnvValue)("LLAMA_INDEXER_V2_ENDPOINT");
 const LLAMA_INDEXER_V2_API_KEY = (0, env_1.getEnvValue)("LLAMA_INDEXER_V2_API_KEY");
 const addressChunkSize = +(0, env_1.getEnvValue)("LLAMA_INDEXER_ADDRESS_CHUNK_SIZE") || 100;
-// v1 chains (still used for balances endpoint) -------------------------------------------------
+const INDEXER_REQUEST_TIMEOUT_MS = +(0, env_1.getEnvValue)("LLAMA_INDEXER_TIMEOUT_MS");
+// v1 chains (still used for balances endpoint)
 const indexerChainIdChainMapping = {
     1: "ethereum",
     10: "optimism",
@@ -52,6 +59,7 @@ const indexer2ChainIdChainMapping = {
     1868: "soneium",
     80094: "berachain",
     999: "hyperliquid",
+    143: "monad",
 };
 const indexerConfigs = {
     v1: {
@@ -65,14 +73,21 @@ const indexerConfigs = {
         chainMapping: indexer2ChainIdChainMapping,
     },
 };
+// http agents for streaming (keep-alive)
+const httpAgent = new http_1.default.Agent({ keepAlive: true, maxSockets: 256, maxFreeSockets: 64 });
+const httpsAgent = new https_1.default.Agent({ keepAlive: true, maxSockets: 256, maxFreeSockets: 64 });
 const axiosInstances = {
     v1: axios_1.default.create({
         headers: { "x-api-key": indexerConfigs.v1.apiKey },
         baseURL: indexerConfigs.v1.endpoint,
+        timeout: INDEXER_REQUEST_TIMEOUT_MS,
     }),
     v2: axios_1.default.create({
         headers: { "x-api-key": indexerConfigs.v2.apiKey },
         baseURL: indexerConfigs.v2.endpoint,
+        httpAgent,
+        httpsAgent,
+        timeout: INDEXER_REQUEST_TIMEOUT_MS,
     }),
 };
 function checkIndexerConfig(version) {
@@ -96,14 +111,8 @@ const chainToIDMapping = {};
 Object.entries(indexerConfigs.v1.chainMapping).forEach(([id, chain]) => {
     chainToIDMapping[chain] = +id;
 });
-const chainToIDMapping2 = {};
-Object.entries(indexerConfigs.v2.chainMapping).forEach(([id, chain]) => {
-    chainToIDMapping2[chain] = +id;
-});
-const state = {
-    chainIndexStatus: {},
-};
-const cacheTime = 1 * 60 * 1000; // 1 min
+const state = { chainIndexStatus: {} };
+const cacheTime = 1 * 60 * 1000; // 1 min
 async function getChainIndexStatus(version = "v2") {
     checkIndexerConfig(version);
     if (state.timestamp && Date.now() - state.timestamp < cacheTime)
@@ -125,17 +134,11 @@ async function getChainIndexStatus(version = "v2") {
     })();
     return state.chainIndexStatus;
 }
-// ---------------------------------------------------------------------------
-// Utilities / Enums / Types
-// ---------------------------------------------------------------------------
 var TokenTypes;
 (function (TokenTypes) {
     TokenTypes["ERC20"] = "erc20";
     TokenTypes["ERC721"] = "erc721";
 })(TokenTypes || (TokenTypes = {}));
-// ---------------------------------------------------------------------------
-// Token helpers (still via v1 endpoint)
-// ---------------------------------------------------------------------------
 async function getTokens(address, { onlyWhitelisted = true, skipCacheRead = false, skipCache = false, chain, tokenType, } = {}) {
     var _a, _b;
     checkIndexerConfig("v1");
@@ -190,38 +193,119 @@ async function getTokens(address, { onlyWhitelisted = true, skipCacheRead = fals
     return tokens;
 }
 // ---------------------------------------------------------------------------
-// LOGS (v2 only)
+// Streaming support (disabled by default, opt-in via clientStreaming: true)
+// ---------------------------------------------------------------------------
+async function streamJsonArrayFromIndexer(opts) {
+    const { path, arrayKey = "logs", onItem, onChunkStats, shouldStop } = opts;
+    const controller = new AbortController();
+    let bytesReceived = 0;
+    let itemsProcessed = 0;
+    const res = await axiosInstances.v2.get(path, {
+        responseType: "stream",
+        timeout: 0,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity,
+        headers: { Accept: "application/json", "Accept-Encoding": "gzip" },
+        signal: controller.signal,
+    }).catch((e) => {
+        if (axios_1.default.isCancel(e) || (e === null || e === void 0 ? void 0 : e.code) === 'ERR_CANCELED')
+            return { data: null };
+        throw (0, common_1.formError)(e);
+    });
+    if (!(res === null || res === void 0 ? void 0 : res.data))
+        return;
+    await new Promise((resolve, reject) => {
+        const stream = res.data;
+        const isCancellationError = (err) => {
+            var _a;
+            return (err === null || err === void 0 ? void 0 : err.name) === "CanceledError" ||
+                ((_a = err === null || err === void 0 ? void 0 : err.message) === null || _a === void 0 ? void 0 : _a.includes("aborted")) ||
+                axios_1.default.isCancel(err) ||
+                (err === null || err === void 0 ? void 0 : err.code) === 'ERR_CANCELED';
+        };
+        const handleError = (err) => isCancellationError(err) ? resolve() : reject(err);
+        stream.on('data', (chunk) => {
+            bytesReceived += chunk.length;
+            onChunkStats === null || onChunkStats === void 0 ? void 0 : onChunkStats({ chunkSize: chunk.length, bytesReceived, itemsProcessed });
+        });
+        const jsonParser = (0, stream_json_1.parser)();
+        const pickFilter = (0, Pick_1.pick)({ filter: arrayKey });
+        const arrayStream = (0, StreamArray_1.streamArray)();
+        arrayStream.on('data', (data) => {
+            if (shouldStop === null || shouldStop === void 0 ? void 0 : shouldStop()) {
+                controller.abort();
+                stream.destroy();
+                return;
+            }
+            try {
+                onItem(data.value);
+                itemsProcessed++;
+                if (itemsProcessed % 100000 === 0) {
+                    onChunkStats === null || onChunkStats === void 0 ? void 0 : onChunkStats({ chunkSize: 100000, bytesReceived, itemsProcessed });
+                }
+            }
+            catch { }
+        });
+        const finish = () => {
+            const rem = itemsProcessed % 100000;
+            if (rem > 0) {
+                onChunkStats === null || onChunkStats === void 0 ? void 0 : onChunkStats({ chunkSize: rem, bytesReceived, itemsProcessed });
+            }
+            resolve();
+        };
+        arrayStream.on('end', finish);
+        arrayStream.on('close', finish);
+        arrayStream.on('error', handleError);
+        jsonParser.on('error', handleError);
+        pickFilter.on('error', handleError);
+        stream.on('error', handleError);
+        stream.pipe(jsonParser).pipe(pickFilter).pipe(arrayStream);
+    });
+}
+// ---------------------------------------------------------------------------
+// LOGS (v2) – streaming opt-in, legacy default
 // ---------------------------------------------------------------------------
 async function getLogs(options) {
-    var _a, _b, _c;
-    let { all = true, limit = 1000, offset: initialOffset = 0, target, targets = [], flatten = true, debugMode = false, noTarget = false, maxBlockRange, processor, } = options;
+    // Set collect=false by default when processor is provided AND collect is not explicitly set AND clientStreaming = true
+    // if you pass processor without collect=true, you won't get results back
+    var _a, _b, _c, _d, _e, _f;
+    let { all = true, limit = 1000, offset: initialOffset = 0, target, targets = [], flatten = true, debugMode = false, noTarget = false, maxBlockRange, processor, clientStreaming = false, // default OFF to keep retro-compat
+    decoderType = "viem", // default to viem for performance
+    onWireStats, onDecodeStats, } = options;
+    if (processor && typeof options.collect === "undefined" && clientStreaming) {
+        options.collect = false;
+    }
     const { chain, fromBlock, toBlock, topic, topic1, topic2, topic3, transformLog, } = await (0, logs_1.getLogParams)(options, true);
+    const viemFastPath = decoderType === "viem" && options.eventAbi
+        ? (0, logs_decode_shared_1.createViemFastPathBatchDecoder)(options.eventAbi)
+        : null;
     if (!debugMode)
         debugMode = debugLog_1.DEBUG_LEVEL2 && !!env_1.ENV_CONSTANTS.GET_LOGS_INDEXER;
+    // === Match logs.ts semantic regarding processor + multiple targets (flatten=false) ===
+    if (processor && (targets === null || targets === void 0 ? void 0 : targets.length) > 1 && !flatten)
+        throw new Error("processor is not supported with multiple targets when flatten=false");
     const blockRange = toBlock - fromBlock;
     const effectiveMaxBlockRange = maxBlockRange !== null && maxBlockRange !== void 0 ? maxBlockRange : (noTarget ? 10000 : Infinity);
     if (noTarget && blockRange > 500000) {
         throw new Error("When noTarget is true, block range must be less than 500k blocks. Please narrow down your block range.");
     }
-    // We now only support v2 for logs ---------------------------------------------------------
+    // Ensure the indexer is synced far enough
     checkIndexerConfig("v2");
     const chainId = getChainId(chain, "v2");
-    // Ensure the indexer is synced far enough
     const chainIndexStatus = await getChainIndexStatus("v2");
     const lastIndexedBlock = (_b = (_a = chainIndexStatus[chain]) === null || _a === void 0 ? void 0 : _a.block) !== null && _b !== void 0 ? _b : 0;
     if (lastIndexedBlock < toBlock) {
         const percentageMissing = ((toBlock - lastIndexedBlock) / (toBlock - fromBlock)) * 100;
-        if (percentageMissing > 50) // more than 50% of the requested range is missing, throw an error and so we pull the logs through rpc calls
+        if (percentageMissing > 50)
             throw new Error(`Indexer not up to date for ${chain}. Last indexed block: ${lastIndexedBlock}, requested block: ${toBlock}`);
         if (env_1.ENV_CONSTANTS.GET_LOGS_INDEXER)
             (0, debugLog_1.debugLog)(`Indexer only partially up to date for ${chain}. Last indexed block: ${lastIndexedBlock}, requested block: ${toBlock}, missing ${Number(percentageMissing).toFixed(2)}%. Pulling part of the logs through RPC calls.`);
-        // now we split the request into two parts, one that goes to the indexer and one that goes through rpc calls
-        const breakBlock = lastIndexedBlock - 50; // we add a small buffer to avoid missing logs due to reorgs
+        const breakBlock = lastIndexedBlock - 50; // small buffer
         const indexerLogs = await getLogs({ ...options, fromBlock, toBlock: breakBlock });
         const rpcLogs = await (0, logs_1.getLogs)({ ...options, fromBlock: breakBlock + 1, toBlock, skipIndexer: true });
         return indexerLogs.concat(rpcLogs);
     }
-    // Re‑curse if the requested range is too large ------------------------------------------------
+    // Re-curse if the requested range is too large
     if (blockRange > effectiveMaxBlockRange) {
         const results = [];
         for (let currentFromBlock = fromBlock; currentFromBlock < toBlock; currentFromBlock += effectiveMaxBlockRange) {
@@ -233,9 +317,6 @@ async function getLogs(options) {
             return results.flat();
         return targets.map((_, i) => results.map((r) => r[i]).flat());
     }
-    // -------------------------------------------------------------------------
-    // Prepare address filters
-    // -------------------------------------------------------------------------
     let address = target;
     if (typeof target === "string")
         targets = [target];
@@ -248,10 +329,177 @@ async function getLogs(options) {
     const addressChunks = (0, _1.sliceIntoChunks)((_c = address === null || address === void 0 ? void 0 : address.split(",")) !== null && _c !== void 0 ? _c : [], addressChunkSize);
     if (noTarget && addressChunks.length === 0)
         addressChunks.push(undefined);
-    // -------------------------------------------------------------------------
-    // Pull logs
-    // -------------------------------------------------------------------------
-    const allLogs = [];
+    // Safely push large arrays without stack overflow (avoid push.apply argument limits (~125k))
+    const safePush = (target, source) => {
+        if (source.length === 0)
+            return;
+        // For very large arrays, split into chunks
+        if (source.length > 100000) {
+            const CHUNK_SIZE = 50000; // Safe chunk size well below push.apply limit
+            for (let i = 0; i < source.length; i += CHUNK_SIZE) {
+                const chunk = source.slice(i, i + CHUNK_SIZE);
+                Array.prototype.push.apply(target, chunk);
+            }
+        }
+        else {
+            Array.prototype.push.apply(target, source);
+        }
+    };
+    // -----------------------------------------------------------------------
+    // Streaming (opt-in) — NO server-side parsing; mirror legacy semantics
+    // -----------------------------------------------------------------------
+    if (clientStreaming) {
+        const useAll = options.all === true;
+        const effectiveLimit = useAll ? Number.POSITIVE_INFINITY : ((_d = options.limit) !== null && _d !== void 0 ? _d : limit);
+        const shouldLimit = !useAll && Number.isFinite(effectiveLimit);
+        const effectiveOffset = useAll ? 0 : ((_f = (_e = options.offset) !== null && _e !== void 0 ? _e : initialOffset) !== null && _f !== void 0 ? _f : 0);
+        const outPairs = [];
+        const start = debugMode ? Date.now() : 0;
+        const MICRO_BATCH_SIZE = +(process.env.LLAMA_INDEXER_MICRO_BATCH || 10000);
+        // Check if we need splitByAddress (mapping by target address)
+        const splitByAddress = (targets === null || targets === void 0 ? void 0 : targets.length) && !flatten;
+        // If splitByAddress, build buckets directly during flushBatch
+        const addressBuckets = splitByAddress ? targets.map(() => []) : [];
+        const addressIndexMap = splitByAddress
+            ? Object.fromEntries(targets.map((t, i) => [t.toLowerCase(), i]))
+            : {};
+        let remainingOffset = effectiveOffset;
+        let remainingLimit = shouldLimit ? effectiveLimit : Number.POSITIVE_INFINITY;
+        const flushBatch = async (batch) => {
+            var _a, _b, _c;
+            if (!batch.length)
+                return;
+            const t0 = Date.now();
+            // Normalize logs before decoding (required for fast-path and consistency)
+            for (const log of batch) {
+                (0, logs_decode_shared_1.normalizeLog)(log, true); // isIndexerCall = true
+            }
+            // Use fast-path if available, otherwise fallback to default
+            const batchFn = viemFastPath !== null && viemFastPath !== void 0 ? viemFastPath : transformLog.batch;
+            let transformedLogs;
+            if (batchFn) {
+                // Fast-path returns only args, need to reconstruct full log objects
+                const decodedArgs = await batchFn(batch);
+                transformedLogs = new Array(batch.length);
+                for (let i = 0; i < batch.length; i++) {
+                    if (options.onlyArgs) {
+                        // If onlyArgs is true, return only the args (like transformLog does)
+                        transformedLogs[i] = decodedArgs[i];
+                    }
+                    else {
+                        transformedLogs[i] = {
+                            ...batch[i],
+                            args: decodedArgs[i]
+                        };
+                        if (!transformedLogs[i].transactionHash && transformedLogs[i]._originalTransactionHash) {
+                            transformedLogs[i].transactionHash = transformedLogs[i]._originalTransactionHash;
+                        }
+                    }
+                }
+            }
+            else {
+                transformedLogs = await Promise.all(batch.map((log) => transformLog(log)));
+            }
+            const decodeTime = Date.now() - t0;
+            onDecodeStats === null || onDecodeStats === void 0 ? void 0 : onDecodeStats({ batchSize: batch.length, decodeTime, itemsDecoded: batch.length });
+            if (processor)
+                await processor(transformedLogs);
+            if (splitByAddress) {
+                // Map directly to address buckets without storing pairs
+                for (let i = 0; i < batch.length; i++) {
+                    const raw = batch[i];
+                    const transformed = transformedLogs[i];
+                    const idx = addressIndexMap[(_c = (_b = ((_a = raw.source) !== null && _a !== void 0 ? _a : raw.address)) === null || _b === void 0 ? void 0 : _b.toLowerCase) === null || _c === void 0 ? void 0 : _c.call(_b)];
+                    if (idx !== undefined) {
+                        addressBuckets[idx].push(transformed);
+                    }
+                }
+            }
+            else if (options.collect !== false) {
+                // Build pairs if collect=true (needed for final return)
+                const pairs = new Array(batch.length);
+                for (let i = 0; i < batch.length; i++) {
+                    pairs[i] = { raw: batch[i], transformed: transformedLogs[i] };
+                }
+                Array.prototype.push.apply(outPairs, pairs);
+            }
+            // If collect=false and not splitByAddress, nothing to store (processor already handled it)
+        };
+        for (const chunk of addressChunks) {
+            if (Array.isArray(chunk) && chunk.length === 0)
+                throw new Error("Address chunk cannot be empty");
+            const qs = new URLSearchParams();
+            qs.set("chainId", String(chainId));
+            qs.set("topic0", topic);
+            if (topic1)
+                qs.set("topic1", topic1);
+            if (topic2)
+                qs.set("topic2", topic2);
+            if (topic3)
+                qs.set("topic3", topic3);
+            if (fromBlock != null)
+                qs.set("from_block", String(fromBlock));
+            if (toBlock != null)
+                qs.set("to_block", String(toBlock));
+            if (chunk && Array.isArray(chunk))
+                qs.set("addresses", chunk.join(",").toLowerCase());
+            if (noTarget)
+                qs.set("noTarget", "true");
+            qs.set("limit", "all");
+            qs.set("offset", "0");
+            const transformBatch = [];
+            let stopNow = false;
+            let flushPromise = Promise.resolve();
+            // Chain flushes sequentially to avoid concurrent decoding (CPU/GC thrashing)
+            const scheduleFlush = (batch) => {
+                flushPromise = flushPromise.then(() => flushBatch(batch));
+            };
+            await streamJsonArrayFromIndexer({
+                path: `/logs?${qs.toString()}`,
+                arrayKey: "logs",
+                onItem: (raw) => {
+                    var _a, _b, _c;
+                    if (stopNow)
+                        return;
+                    const okAddress = !addressSet.size || addressSet.has((_c = (_b = ((_a = raw.source) !== null && _a !== void 0 ? _a : raw.address)) === null || _b === void 0 ? void 0 : _b.toLowerCase) === null || _c === void 0 ? void 0 : _c.call(_b));
+                    if (!okAddress)
+                        return;
+                    if (remainingOffset > 0) {
+                        remainingOffset--;
+                        return;
+                    }
+                    if (remainingLimit <= 0) {
+                        stopNow = true;
+                        return;
+                    }
+                    transformBatch.push(raw);
+                    remainingLimit--;
+                    if (transformBatch.length >= MICRO_BATCH_SIZE) {
+                        // Sequential flush: chain to avoid concurrent decoding
+                        const batch = transformBatch.splice(0, MICRO_BATCH_SIZE);
+                        scheduleFlush(batch);
+                    }
+                },
+                shouldStop: () => stopNow,
+                onChunkStats: (s) => onWireStats === null || onWireStats === void 0 ? void 0 : onWireStats(s),
+            });
+            if (transformBatch.length > 0) {
+                scheduleFlush(transformBatch.splice(0, transformBatch.length));
+            }
+            await flushPromise;
+            if (remainingLimit <= 0)
+                break;
+        }
+        if (debugMode) {
+            const ms = Date.now() - start;
+            (0, debugLog_1.debugLog)(`[Indexer] stream finished: ${outPairs.length} items in ${ms}ms`);
+        }
+        if (splitByAddress) {
+            return addressBuckets;
+        }
+        return (options.collect !== false) ? outPairs.map(i => i.transformed) : [];
+    }
+    const allLogsPairs = [];
     const debugTimeKey = `Indexer-getLogs-${chain}-${topic}-${address}_${Math.random()}`;
     if (debugMode) {
         (0, debugLog_1.debugLog)("[Indexer] Pulling logs " + debugTimeKey);
@@ -276,65 +524,77 @@ async function getLogs(options) {
                 limit,
                 offset: chunkOffset,
                 noTarget,
-                eventAbi: options.eventAbi,
-                parseLog: options.parseLog,
-                onlyArgs: options.onlyArgs,
             };
             const { data: { logs: _logs, totalCount }, } = await axiosInstances.v2(`/logs`, { params }).catch(e => { throw (0, common_1.formError)(e); });
             const filtered = _logs.filter((l) => {
-                const isWhitelisted = !addressSet.size || addressSet.has(l.source.toLowerCase());
-                if (!isWhitelisted)
-                    return false;
-                if (l.block_number) {
-                    l.blockNumber = parseInt(l.block_number);
-                }
-                return true;
+                var _a, _b, _c;
+                const isWhitelisted = !addressSet.size || addressSet.has((_c = (_b = ((_a = l.source) !== null && _a !== void 0 ? _a : l.address)) === null || _b === void 0 ? void 0 : _b.toLowerCase) === null || _c === void 0 ? void 0 : _c.call(_b));
+                return !!isWhitelisted;
             });
-            // we need to the { raw, transformed } structure to allow for post‑processing like clustering based on `source` field
-            const transformed = filtered.map((log) => ({ raw: log, transformed: transformLog(log) }));
+            const t0 = Date.now();
+            // Normalize logs before decoding (required for consistency)
+            for (const log of filtered) {
+                (0, logs_decode_shared_1.normalizeLog)(log, true); // isIndexerCall = true
+            }
+            // Legacy path: use transformLog batch if available, otherwise transform individually
+            const transformBatchFn = transformLog.batch || ((logs) => Promise.all(logs.map((log) => transformLog(log))));
+            const transformedLogs = await transformBatchFn(filtered);
+            const transformedPair = filtered.map((log, idx) => ({ raw: log, transformed: transformedLogs[idx] }));
+            const decodeTime = Date.now() - t0;
+            if (onDecodeStats && filtered.length > 0)
+                onDecodeStats({ batchSize: filtered.length, decodeTime, itemsDecoded: filtered.length });
             if (processor)
-                await processor(transformed.map((i) => i.transformed));
-            allLogs.push(...transformed);
+                await processor(transformedPair.map((i) => i.transformed));
+            // Safe push helper to avoid stack overflow on large arrays
+            // Only accumulate if collect is enabled (default true for backward compatibility)
+            const shouldCollect = (options.collect !== false);
+            if (shouldCollect) {
+                safePush(allLogsPairs, transformedPair);
+            }
             logCount += _logs.length;
             chunkOffset += limit;
-            if (_logs.length < limit || totalCount <= logCount || _logs.length === 0)
+            if (_logs.length === 0) {
+                hasMore = false;
+            }
+            else if (_logs.length < limit) {
+                hasMore = false;
+            }
+            else if (typeof totalCount === 'number' && totalCount <= logCount) {
                 hasMore = false;
+            }
+            else {
+                hasMore = true;
+            }
         } while (all && hasMore);
     }
     if (debugMode) {
         console.timeEnd(debugTimeKey);
-        (0, debugLog_1.debugLog)("Logs pulled " + chain, address, allLogs.length);
+        (0, debugLog_1.debugLog)("Logs pulled " + chain, address, allLogsPairs.length);
     }
-    // -------------------------------------------------------------------------
-    // Map / transform result
-    // -------------------------------------------------------------------------
     const splitByAddress = (targets === null || targets === void 0 ? void 0 : targets.length) && !flatten;
     if (splitByAddress) {
         const mapped = targets.map(() => []);
         const indexMap = {};
         targets.forEach((t, i) => (indexMap[t.toLowerCase()] = i));
-        allLogs.forEach(({ raw, transformed }) => {
-            const idx = indexMap[raw.source.toLowerCase()];
+        allLogsPairs.forEach(({ raw, transformed }) => {
+            var _a, _b, _c;
+            const idx = indexMap[(_c = (_b = ((_a = raw.source) !== null && _a !== void 0 ? _a : raw.address)) === null || _b === void 0 ? void 0 : _b.toLowerCase) === null || _c === void 0 ? void 0 : _c.call(_b)];
             if (idx === undefined)
                 return; // ignore unknown sources
             mapped[idx].push(transformed);
         });
         return mapped;
     }
-    return allLogs.map(i => i.transformed);
+    // Return empty array if collect=false (processor handles results)
+    const shouldCollect = (options.collect !== false);
+    return shouldCollect ? allLogsPairs.map(i => i.transformed) : [];
 }
-// ---------------------------------------------------------------------------
-// TOKEN TRANSFERS (v2 only)
-// ---------------------------------------------------------------------------
 async function getTokenTransfers({ chain = "ethereum", fromAddressFilter, fromBlock, toBlock, all = true, limit = 1000, offset = 0, target, targets = [], flatten = true, fromTimestamp, toTimestamp, debugMode = false, transferType = "in", token, tokens, }) {
     var _a, _b;
     if (!debugMode)
         debugMode = debugLog_1.DEBUG_LEVEL2 && !!env_1.ENV_CONSTANTS.GET_LOGS_INDEXER;
     checkIndexerConfig("v2");
     const chainId = getChainId(chain, "v2");
-    // -----------------------------------------------------------------------
-    // Input validation & pre‑processing
-    // -----------------------------------------------------------------------
     const fromFilterEnabled = !!(fromAddressFilter === null || fromAddressFilter === void 0 ? void 0 : fromAddressFilter.length);
     if (typeof fromAddressFilter === "string")
         fromAddressFilter = [fromAddressFilter];
@@ -364,15 +624,12 @@ async function getTokenTransfers({ chain = "ethereum", fromAddressFilter, fromBl
         throw new Error("target|targets is required");
     targets = targets.map((t) => t.toLowerCase());
     const addresses = targets.join(",");
-    // Ensure v2 indexer is up‑to‑date
+    // Ensure v2 indexer is up-to-date
     const chainIndexStatus = await getChainIndexStatus("v2");
     const lastIndexedBlock = (_b = (_a = chainIndexStatus[chain]) === null || _a === void 0 ? void 0 : _a.block) !== null && _b !== void 0 ? _b : 0;
     if (lastIndexedBlock < toBlock) {
         throw new Error(`Indexer not up to date for ${chain}. Last indexed block: ${lastIndexedBlock}, requested block: ${toBlock}`);
     }
-    // -----------------------------------------------------------------------
-    // Fetch transfers
-    // -----------------------------------------------------------------------
     const rawTransfers = [];
     const debugTimeKey = `Indexer-tokenTransfers-${chain}-${addresses}_${Math.random()}`;
     if (debugMode) {
@@ -407,11 +664,10 @@ async function getTokenTransfers({ chain = "ethereum", fromAddressFilter, fromBl
             default:
                 throw new Error("Invalid transferType");
         }
-        const { data: { transfers: _logs, totalCount }, } = await axiosInstances.v2(`/token-transfers`, { params }).catch(e => { throw (0, common_1.formError)(e); });
+        const { data: { transfers: _logs }, } = await axiosInstances.v2(`/token-transfers`, { params }).catch(e => { throw (0, common_1.formError)(e); });
         rawTransfers.push(..._logs);
         currentOffset += limit;
-        if (_logs.length < limit || totalCount <= rawTransfers.length || _logs.length === 0)
-            hasMore = false;
+        hasMore = _logs.length === limit;
     } while (all && hasMore);
     const filteredTransfers = rawTransfers.filter((l) => {
         if (!fromFilterEnabled)
@@ -422,9 +678,6 @@ async function getTokenTransfers({ chain = "ethereum", fromAddressFilter, fromBl
         console.timeEnd(debugTimeKey);
         (0, debugLog_1.debugLog)("Token Transfers pulled " + chain, addresses, filteredTransfers.length);
     }
-    // -----------------------------------------------------------------------
-    // Split result if requested
-    // -----------------------------------------------------------------------
     const splitByAddress = (targets === null || targets === void 0 ? void 0 : targets.length) && !flatten;
     if (splitByAddress) {
         const mapped = targets.map(() => []);
@@ -440,9 +693,6 @@ async function getTokenTransfers({ chain = "ethereum", fromAddressFilter, fromBl
     }
     return filteredTransfers;
 }
-// ---------------------------------------------------------------------------
-// TRANSACTIONS (v2 only)
-// ---------------------------------------------------------------------------
 async function getTransactions({ chain = "ethereum", addresses, transaction_hashes, from_block, to_block, all = true, limit = 1000, offset = 0, debugMode = false, transactionType = "from", }) {
     var _a, _b;
     if (!debugMode)
@@ -515,11 +765,7 @@ async function getTransactions({ chain = "ethereum", addresses, transaction_hash
         timestamp: t.timestamp,
     }));
 }
-// ---------------------------------------------------------------------------
-// Public helpers
-// ---------------------------------------------------------------------------
 function isIndexerEnabled(chain) {
-    // Legacy function kept for backward‑compat: return true if v2 is enabled
     if (!indexerConfigs.v2.endpoint)
         return false;
     if (chain && !exports.supportedChainSet2.has(chain))
@@ -527,6 +773,5 @@ function isIndexerEnabled(chain) {
     return true;
 }
 function isIndexer2Enabled(chain) {
-    // Alias – retained so external calls do not break
     return isIndexerEnabled(chain);
 }

package/build/util/logs.decode.shared.d.ts

@@ -0,0 +1,8 @@
+import { ethers, Interface } from "ethers";
+export declare function padTopic32(t: string): `0x${string}`;
+export declare function normalizeLog(log: any, isIndexerCall?: boolean): boolean;
+export declare function normalizeValueByType(value: any, type: string): any;
+export declare function convertTopicsToViemFormat(topics: any[]): [`0x${string}`, ...(`0x${string}`[] | [])] | [];
+export declare function enrichEthersArgsWithNamedProperties(ethersArgs: any, event: ethers.EventFragment | null, iface: Interface): any;
+export declare function buildEthersCompatibleArgs(decodedArgs: any, eventInputs: readonly ethers.ParamType[], normalizeFn?: (value: any, type: string) => any): any;
+export declare function createViemFastPathBatchDecoder(eventAbi: string | any): ((logs: any[]) => Promise<any[]>) | null;