@defillama/sdk 5.0.235 → 5.0.238

package/build/util/indexer.js

@@ -14,6 +14,7 @@ exports.isIndexer2Enabled = isIndexer2Enabled;
 const axios_1 = __importDefault(require("axios"));
 const http_1 = __importDefault(require("http"));
 const https_1 = __importDefault(require("https"));
+const promises_1 = require("stream/promises");
 const stream_json_1 = require("stream-json");
 const Pick_1 = require("stream-json/filters/Pick");
 const StreamArray_1 = require("stream-json/streamers/StreamArray");
@@ -24,11 +25,12 @@ 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 indexer_compatibility_1 = require("./indexer.compatibility");
 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 LLAMA_INDEXER_V4_ENDPOINT = (0, env_1.getEnvValue)("LLAMA_INDEXER_V4_ENDPOINT");
 const LLAMA_INDEXER_V4_API_KEY = (_a = (0, env_1.getEnvValue)("LLAMA_INDEXER_V4_API_KEY")) !== null && _a !== void 0 ? _a : LLAMA_INDEXER_V2_API_KEY;
-const LLAMA_INDEXER_PREFER_V4 = (0, env_1.getEnvValue)("LLAMA_INDEXER_PREFER_V4") === "true"; // route all chains through v4
+const LLAMA_INDEXER_PREFER_V4 = (0, env_1.getEnvValue)("LLAMA_INDEXER_PREFER_V4") !== "false"; // explicit false allows rollback
 const addressChunkSize = +(0, env_1.getEnvValue)("LLAMA_INDEXER_ADDRESS_CHUNK_SIZE") || 100;
 const INDEXER_REQUEST_TIMEOUT_MS = +(0, env_1.getEnvValue)("LLAMA_INDEXER_TIMEOUT_MS");
 const indexerChainIdChainMapping = {
@@ -76,31 +78,29 @@ const indexerConfigs = {
     v2: { endpoint: LLAMA_INDEXER_V2_ENDPOINT, apiKey: LLAMA_INDEXER_V2_API_KEY },
     v4: { endpoint: LLAMA_INDEXER_V4_ENDPOINT, apiKey: LLAMA_INDEXER_V4_API_KEY },
 };
-// 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 = {
-    v2: axios_1.default.create({
-        headers: { "x-api-key": LLAMA_INDEXER_V2_API_KEY },
-        baseURL: LLAMA_INDEXER_V2_ENDPOINT,
-        httpAgent,
-        httpsAgent,
-        timeout: INDEXER_REQUEST_TIMEOUT_MS,
-    }),
-    v4: axios_1.default.create({
-        headers: { "x-api-key": LLAMA_INDEXER_V4_API_KEY },
-        baseURL: LLAMA_INDEXER_V4_ENDPOINT,
+function createIndexerClient(version) {
+    const { endpoint, apiKey } = indexerConfigs[version];
+    return axios_1.default.create({
+        headers: { "x-api-key": apiKey },
+        baseURL: endpoint,
         httpAgent,
         httpsAgent,
         timeout: INDEXER_REQUEST_TIMEOUT_MS,
-    }),
+    });
+}
+const axiosInstances = {
+    v2: createIndexerClient("v2"),
+    v4: createIndexerClient("v4"),
 };
+const INDEXER_HEAD_BUFFER = 50;
 function checkIndexerConfig(version) {
     const { endpoint, apiKey } = indexerConfigs[version];
     if (!endpoint || !apiKey)
         throw new Error(`Llama Indexer (${version}) URL/api key is not set`);
 }
-// v4-only chains always go to v4; the rest go to v2 unless PREFER_V4 is set or v2 is not configured
+// Prefer a configured v4 deployment; retain v2-only installations and explicit rollback.
 function getChainIndexerVersion(chain) {
     if (v4OnlyChainSet.has(chain))
         return "v4";
@@ -117,13 +117,7 @@ function getChainId(chain) {
         throw new Error("Chain not supported");
     return +chainId;
 }
-function getSupportedChains() {
-    return new Set(Object.values(allChainIdChainMapping));
-}
-exports.supportedChainSet2 = getSupportedChains();
-function supportsCursorPagination(version) {
-    return version === "v4";
-}
+exports.supportedChainSet2 = new Set(Object.values(allChainIdChainMapping));
 function getLogCursor(log) {
     var _a, _b, _c;
     if (!log)
@@ -142,13 +136,14 @@ function getTransferCursor(transfer) {
         cursor.after_id = String(transfer.id);
     return cursor;
 }
-function applyCursorParams(params, cursor) {
-    if (!cursor)
+function getTransactionCursor(transaction) {
+    if (!transaction)
         return;
-    params.after_block = cursor.after_block;
-    params.after_index = cursor.after_index;
-    if (cursor.after_id !== undefined)
-        params.after_id = cursor.after_id;
+    return { after_block: +transaction.block_number, after_index: +transaction.transaction_index };
+}
+function safePush(target, source) {
+    for (const row of source)
+        target.push(row);
 }
 function applyLocalOffset(rows, remainingOffset) {
     if (remainingOffset <= 0)
@@ -157,6 +152,72 @@ function applyLocalOffset(rows, remainingOffset) {
         return { rows: [], remainingOffset: remainingOffset - rows.length };
     return { rows: rows.slice(remainingOffset), remainingOffset: 0 };
 }
+function assertCursorAdvances(next, previous) {
+    if (!next || !Number.isSafeInteger(next.after_block) || !Number.isSafeInteger(next.after_index))
+        throw new Error("Indexer v4 returned a page without a valid cursor");
+    if (!previous)
+        return;
+    const advances = next.after_block > previous.after_block ||
+        (next.after_block === previous.after_block && (next.after_index > previous.after_index ||
+            (next.after_index === previous.after_index && next.after_id !== undefined && previous.after_id !== undefined &&
+                BigInt(next.after_id) > BigInt(previous.after_id))));
+    if (!advances)
+        throw new Error("Indexer v4 pagination cursor did not advance");
+}
+// Translate the public offset/limit contract into keyset pagination. Even all=false
+// may need several requests: the v4 server caps offsets, not the public SDK API.
+async function* getV4Pages(path, key, params, limit, offset, all, getCursor) {
+    if (!Number.isSafeInteger(limit) || limit < 0 || !Number.isSafeInteger(offset) || offset < 0)
+        throw new Error("Indexer pagination requires a non-negative integer limit and offset");
+    if (limit === 0)
+        return;
+    let cursor;
+    let remainingOffset = offset;
+    let remainingLimit = all ? Infinity : limit;
+    while (remainingLimit > 0) {
+        const pageParams = { ...params, limit, offset: 0, includeTotal: false, ...cursor };
+        const response = await axiosInstances.v4(path, {
+            params: pageParams,
+            ...(key === "transfers" ? { responseType: "text", transformResponse: (data) => data } : {}),
+        }).catch((e) => { throw (0, common_1.formError)(e); });
+        const data = key === "transfers" && typeof response.data === "string"
+            ? await (0, indexer_compatibility_1.parseTransferResponse)(response.data) : response.data;
+        const page = data[key];
+        if (!Array.isArray(page))
+            throw new Error(`Indexer v4 returned an invalid ${key} response`);
+        // Capture the cursor before consumers normalize/mutate the raw rows.
+        const next = getCursor(page[page.length - 1]);
+        const result = applyLocalOffset(page, remainingOffset);
+        remainingOffset = result.remainingOffset;
+        const rows = result.rows.slice(0, remainingLimit);
+        remainingLimit -= rows.length;
+        const hasMore = page.length >= limit && remainingLimit > 0;
+        if (hasMore || (page.length && cursor))
+            assertCursorAdvances(next, cursor);
+        if (rows.length)
+            yield rows.map(row => (0, indexer_compatibility_1.normalizeV4Row)(row, key));
+        if (!hasMore)
+            return;
+        cursor = next;
+    }
+}
+async function* getIndexerPages(version, path, key, params, limit, offset, all, getCursor) {
+    if (version === "v4") {
+        yield* getV4Pages(path, key, params, limit, offset, all, getCursor);
+        return;
+    }
+    let count = 0;
+    do {
+        const { data } = await axiosInstances.v2(path, { params: { ...params, limit, offset } })
+            .catch((e) => { throw (0, common_1.formError)(e); });
+        const rows = data[key];
+        yield rows;
+        count += rows.length;
+        if (!rows.length || rows.length < limit || (key === "logs" && typeof data.totalCount === "number" && data.totalCount <= count))
+            return;
+        offset += limit;
+    } while (all);
+}
 const syncStates = {
     v2: { chainIndexStatus: {} },
     v4: { chainIndexStatus: {} },
@@ -181,94 +242,88 @@ async function getChainIndexStatus(version) {
             }
         });
         return (state.chainIndexStatus = info);
-    })();
+    })().catch((error) => {
+        state.timestamp = undefined;
+        state.chainIndexStatus = {};
+        throw error;
+    });
     return state.chainIndexStatus;
 }
-// ---------------------------------------------------------------------------
-// Streaming support (disabled by default, opt-in via clientStreaming: true)
-// ---------------------------------------------------------------------------
-async function streamJsonArrayFromIndexer(opts) {
-    const { path, version, arrayKey = "logs", onItem, onChunkStats, shouldStop } = opts;
+async function streamLogs(opts) {
+    const { path, version, onItem, onChunkStats, shouldStop } = opts;
     const controller = new AbortController();
     let bytesReceived = 0;
     let itemsProcessed = 0;
     const res = await axiosInstances[version].get(path, {
         responseType: "stream",
-        timeout: 0,
+        timeout: INDEXER_REQUEST_TIMEOUT_MS,
         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;
+    }).catch((e) => { throw (0, common_1.formError)(e); });
+    let stopped = false;
+    let processingError;
+    try {
+        await (0, promises_1.pipeline)(res.data, async function* (source) {
+            for await (const chunk of source) {
+                bytesReceived += chunk.length;
+                onChunkStats === null || onChunkStats === void 0 ? void 0 : onChunkStats({ chunkSize: chunk.length, bytesReceived, itemsProcessed });
+                yield chunk;
             }
-            try {
-                onItem(data.value);
+        }, (0, stream_json_1.parser)(), (0, Pick_1.pick)({ filter: "logs" }), (0, StreamArray_1.streamArray)(), async (source) => {
+            for await (const { value } of source) {
+                try {
+                    await onItem(value);
+                }
+                catch (e) {
+                    processingError = e;
+                    throw e;
+                }
                 itemsProcessed++;
-                if (itemsProcessed % 100000 === 0) {
-                    onChunkStats === null || onChunkStats === void 0 ? void 0 : onChunkStats({ chunkSize: 100000, bytesReceived, itemsProcessed });
+                if (shouldStop === null || shouldStop === void 0 ? void 0 : shouldStop()) {
+                    stopped = true;
+                    controller.abort();
+                    break;
                 }
             }
-            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);
+    }
+    catch (e) {
+        // Only our requested early stop is successful; remote truncation and decode
+        // or processor errors must reject instead of returning incomplete results.
+        if (!stopped)
+            throw processingError !== null && processingError !== void 0 ? processingError : e;
+    }
+    onChunkStats === null || onChunkStats === void 0 ? void 0 : onChunkStats({ chunkSize: 0, bytesReceived, itemsProcessed });
+}
+async function decodeStreamingLogs(logs, transformLog, batchDecoder, onlyArgs) {
+    for (const log of logs)
+        (0, logs_decode_shared_1.normalizeLog)(log, true);
+    if (!batchDecoder)
+        return Promise.all(logs.map(log => transformLog(log)));
+    // The historical streaming fast path returns args without buffered parsedLog metadata.
+    const args = await batchDecoder(logs);
+    return logs.map((log, i) => {
+        if (onlyArgs)
+            return args[i];
+        const decoded = { ...log, args: args[i] };
+        if (!decoded.transactionHash && decoded._originalTransactionHash)
+            decoded.transactionHash = decoded._originalTransactionHash;
+        return decoded;
     });
 }
-// ---------------------------------------------------------------------------
-// LOGS (v2) – streaming opt-in, legacy default
-// ---------------------------------------------------------------------------
 async function getLogs(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;
+    var _a, _b, _c, _d, _e;
+    let { all = true, limit = 1000, offset: initialOffset = 0, target, targets = [], flatten = true, debugMode = false, noTarget = false, maxBlockRange, processor, clientStreaming = false, decoderType = "viem", onWireStats, onDecodeStats, } = options;
     if (processor && typeof options.collect === "undefined" && clientStreaming) {
-        options.collect = false;
+        options = { ...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
+    const { chain, fromBlock, toBlock, topic, topic1, topic2, topic3, topics, transformLog, } = await (0, logs_1.getLogParams)(options, true);
+    const viemFastPath = 
+    // Preserve the historical streaming shape, including entireLog: the viem
+    // fast path exposes args without adding the buffered decoder's parsedLog.
+    decoderType === "viem" && options.eventAbi && options.parseLog !== false && !options.allowParseFailure
         ? (0, logs_decode_shared_1.createViemFastPathBatchDecoder)(options.eventAbi)
         : null;
     if (!debugMode)
@@ -277,7 +332,11 @@ async function getLogs(options) {
     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;
+    if (!Number.isSafeInteger(fromBlock) || !Number.isSafeInteger(toBlock) || fromBlock > toBlock)
+        throw new Error("getLogs requires integer block bounds with fromBlock <= toBlock");
     const effectiveMaxBlockRange = maxBlockRange !== null && maxBlockRange !== void 0 ? maxBlockRange : (noTarget ? 10000 : Infinity);
+    if (!(effectiveMaxBlockRange > 0) || (effectiveMaxBlockRange !== Infinity && !Number.isSafeInteger(effectiveMaxBlockRange)))
+        throw new Error("maxBlockRange must be a positive integer");
     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.");
     }
@@ -286,33 +345,32 @@ async function getLogs(options) {
     checkIndexerConfig(indexerVersion);
     const chainId = getChainId(chain);
     const chainIndexStatus = await getChainIndexStatus(indexerVersion);
-    const lastIndexedBlock = (_b = (_a = chainIndexStatus[chain]) === null || _a === void 0 ? void 0 : _a.block) !== null && _b !== void 0 ? _b : 0;
+    const lastIndexedBlock = Number((_b = (_a = chainIndexStatus[chain]) === null || _a === void 0 ? void 0 : _a.block) !== null && _b !== void 0 ? _b : 0);
+    if (!Number.isSafeInteger(lastIndexedBlock) || lastIndexedBlock < 0)
+        throw new Error(`Indexer returned an invalid last indexed block for ${chain}`);
     if (lastIndexedBlock < toBlock) {
         const percentageMissing = ((toBlock - lastIndexedBlock) / (toBlock - fromBlock)) * 100;
         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.`);
-        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 });
-        // When flatten=false, preserve per-target buckets: merge RPC logs into their corresponding indexer bucket so the result still maintains one element per target.
-        if (!flatten) {
-            return indexerLogs.map((bucket, i) => bucket.concat(rpcLogs[i]));
-        }
-        return indexerLogs.concat(rpcLogs);
+        // An empty indexer prefix uses RPC for exactly the original window. The two
+        // inclusive ranges otherwise meet at breakBlock / breakBlock + 1.
+        const breakBlock = Math.max(fromBlock - 1, lastIndexedBlock - INDEXER_HEAD_BUFFER);
+        return getPartiallyIndexedLogs(breakBlock);
     }
     // Re-curse if the requested range is too large
     if (blockRange > effectiveMaxBlockRange) {
         const results = [];
-        for (let currentFromBlock = fromBlock; currentFromBlock < toBlock; currentFromBlock += effectiveMaxBlockRange) {
+        for (let currentFromBlock = fromBlock; currentFromBlock <= toBlock; currentFromBlock += effectiveMaxBlockRange) {
             const currentToBlock = Math.min(currentFromBlock + effectiveMaxBlockRange - 1, toBlock);
             const chunk = await getLogs({ ...options, fromBlock: currentFromBlock, toBlock: currentToBlock });
             results.push(chunk);
         }
-        if (flatten || !(targets === null || targets === void 0 ? void 0 : targets.length))
+        const splitTargets = typeof target === "string" ? [target] : targets;
+        if (flatten || !splitTargets.length)
             return results.flat();
-        return targets.map((_, i) => results.map((r) => r[i]).flat());
+        return splitTargets.map((_, i) => results.map((r) => r[i]).flat());
     }
     let address = target;
     if (typeof target === "string")
@@ -326,36 +384,15 @@ 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);
-    // 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 = 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 effectiveOffset = (_e = options.offset) !== null && _e !== void 0 ? _e : initialOffset;
+        const collected = [];
         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]))
@@ -367,42 +404,12 @@ async function getLogs(options) {
             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 transformedLogs = await decodeStreamingLogs(batch, transformLog, viemFastPath !== null && viemFastPath !== void 0 ? viemFastPath : transformLog.batch, options.onlyArgs);
             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
+            if (splitByAddress && options.collect !== false) {
                 for (let i = 0; i < batch.length; i++) {
                     const raw = batch[i];
                     const transformed = transformedLogs[i];
@@ -413,14 +420,8 @@ async function getLogs(options) {
                 }
             }
             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);
+                safePush(collected, transformedLogs);
             }
-            // 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)
@@ -446,19 +447,15 @@ async function getLogs(options) {
             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({
+            await streamLogs({
                 path: `/logs?${qs.toString()}`,
                 version: indexerVersion,
-                arrayKey: "logs",
-                onItem: (raw) => {
+                onItem: async (raw) => {
                     var _a, _b, _c;
                     if (stopNow)
                         return;
+                    if (indexerVersion === "v4")
+                        (0, indexer_compatibility_1.normalizeV4Row)(raw, "logs");
                     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;
@@ -472,30 +469,30 @@ async function getLogs(options) {
                     }
                     transformBatch.push(raw);
                     remainingLimit--;
+                    if (remainingLimit <= 0)
+                        stopNow = true;
                     if (transformBatch.length >= MICRO_BATCH_SIZE) {
-                        // Sequential flush: chain to avoid concurrent decoding
                         const batch = transformBatch.splice(0, MICRO_BATCH_SIZE);
-                        scheduleFlush(batch);
+                        await flushBatch(batch);
                     }
                 },
                 shouldStop: () => stopNow,
-                onChunkStats: (s) => onWireStats === null || onWireStats === void 0 ? void 0 : onWireStats(s),
+                onChunkStats: onWireStats,
             });
             if (transformBatch.length > 0) {
-                scheduleFlush(transformBatch.splice(0, transformBatch.length));
+                await flushBatch(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`);
+            (0, debugLog_1.debugLog)(`[Indexer] stream finished: ${collected.length} items in ${ms}ms`);
         }
         if (splitByAddress) {
             return addressBuckets;
         }
-        return (options.collect !== false) ? outPairs.map(i => i.transformed) : [];
+        return collected;
     }
     const allLogsPairs = [];
     const debugTimeKey = `Indexer-getLogs-${chain}-${topic}-${address}_${Math.random()}`;
@@ -503,48 +500,24 @@ async function getLogs(options) {
         (0, debugLog_1.debugLog)("[Indexer] Pulling logs " + debugTimeKey);
         console.time(debugTimeKey);
     }
-    const useCursorPagination = supportsCursorPagination(indexerVersion) && all;
     for (const chunk of addressChunks) {
         if (Array.isArray(chunk) && chunk.length === 0)
             throw new Error("Address chunk cannot be empty");
-        let chunkOffset = useCursorPagination ? 0 : initialOffset;
-        let remainingOffset = useCursorPagination ? initialOffset : 0;
-        let logCount = 0;
-        let hasMore = true;
-        let cursor;
-        do {
-            const params = {
-                addresses: hasAddressFilter ? chunk === null || chunk === void 0 ? void 0 : chunk.join(",") : undefined,
-                chainId,
-                topic0: topic,
-                from_block: fromBlock,
-                to_block: toBlock,
-                topic1,
-                topic2,
-                topic3,
-                limit,
-                offset: chunkOffset,
-                noTarget,
-            };
-            if (useCursorPagination) {
-                params.includeTotal = false;
-                applyCursorParams(params, cursor);
-            }
-            const { data: { logs: _logs, totalCount }, } = await axiosInstances[indexerVersion](`/logs`, { params }).catch((e) => { throw (0, common_1.formError)(e); });
-            const nextCursor = useCursorPagination ? getLogCursor(_logs[_logs.length - 1]) : undefined;
-            const offsetResult = useCursorPagination ? applyLocalOffset(_logs, remainingOffset) : { rows: _logs, remainingOffset };
-            remainingOffset = offsetResult.remainingOffset;
-            const filtered = offsetResult.rows.filter((l) => {
+        const params = {
+            addresses: hasAddressFilter ? chunk === null || chunk === void 0 ? void 0 : chunk.join(",") : undefined,
+            chainId, topic0: topic, from_block: fromBlock, to_block: toBlock,
+            topic1, topic2, topic3, noTarget,
+        };
+        for await (const rows of getIndexerPages(indexerVersion, "/logs", "logs", params, limit, initialOffset, all, getLogCursor)) {
+            const filtered = rows.filter((l) => {
                 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;
             });
             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
+                (0, logs_decode_shared_1.normalizeLog)(log, 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] }));
@@ -553,33 +526,10 @@ async function getLogs(options) {
                 onDecodeStats({ batchSize: filtered.length, decodeTime, itemsDecoded: filtered.length });
             if (processor)
                 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) {
+            if (options.collect !== false) {
                 safePush(allLogsPairs, transformedPair);
             }
-            logCount += _logs.length;
-            if (useCursorPagination && nextCursor) {
-                cursor = nextCursor;
-                chunkOffset = 0;
-            }
-            else {
-                chunkOffset += limit;
-            }
-            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);
@@ -599,9 +549,111 @@ async function getLogs(options) {
         });
         return mapped;
     }
-    // Return empty array if collect=false (processor handles results)
-    const shouldCollect = (options.collect !== false);
-    return shouldCollect ? allLogsPairs.map(i => i.transformed) : [];
+    return allLogsPairs.map(i => i.transformed);
+    async function getPartiallyIndexedLogs(breakBlock) {
+        if (!Number.isSafeInteger(limit) || limit < 0 || !Number.isSafeInteger(initialOffset) || initialOffset < 0)
+            throw new Error("Indexer pagination requires a non-negative integer limit and offset");
+        const requestedTargets = typeof target === "string" ? [target] : targets;
+        const uniqueTargets = [...new Set(requestedTargets.map(t => t.toLowerCase()))];
+        const splitByAddress = requestedTargets.length > 0 && !flatten;
+        const collected = splitByAddress ? requestedTargets.map(() => []) : [];
+        const targetBuckets = new Map();
+        requestedTargets.forEach((t, i) => {
+            var _a;
+            const key = t.toLowerCase();
+            targetBuckets.set(key, [...((_a = targetBuckets.get(key)) !== null && _a !== void 0 ? _a : []), i]);
+        });
+        let remainingOffset = initialOffset;
+        let remainingLimit = all ? Infinity : limit;
+        if (limit === 0)
+            return collected;
+        const rpcTransform = (await (0, logs_1.getLogParams)(options, false)).transformLog;
+        const finished = Symbol("partial log limit reached");
+        let seenBlock;
+        const seen = new Set();
+        async function consume(rawRows, isIndexer, start, end) {
+            var _a, _b, _c, _d;
+            const selected = [];
+            for (const row of rawRows) {
+                const block = Number((_a = row.blockNumber) !== null && _a !== void 0 ? _a : row.block_number);
+                if (!Number.isSafeInteger(block))
+                    throw new Error("Log returned without a valid block number");
+                if (block < start || block > end)
+                    continue;
+                if (block !== seenBlock) {
+                    seenBlock = block;
+                    seen.clear();
+                }
+                const hash = (_b = row.transactionHash) !== null && _b !== void 0 ? _b : row.transaction_hash;
+                const index = (_d = (_c = row.logIndex) !== null && _c !== void 0 ? _c : row.index) !== null && _d !== void 0 ? _d : row.log_index;
+                if (hash !== undefined && index !== undefined) {
+                    const key = `${String(hash).toLowerCase()}:${index}`;
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                }
+                if (remainingOffset > 0) {
+                    remainingOffset--;
+                    continue;
+                }
+                if (remainingLimit <= 0)
+                    break;
+                selected.push(clientStreaming && !isIndexer ? { ...row } : row);
+                remainingLimit--;
+            }
+            if (selected.length) {
+                const transform = isIndexer ? transformLog : rpcTransform;
+                const startTime = Date.now();
+                const decoded = clientStreaming
+                    ? await decodeStreamingLogs(selected, transform, viemFastPath !== null && viemFastPath !== void 0 ? viemFastPath : transform.batch, options.onlyArgs)
+                    : await Promise.all(selected.map(row => transform(row)));
+                onDecodeStats === null || onDecodeStats === void 0 ? void 0 : onDecodeStats({ batchSize: selected.length, decodeTime: Date.now() - startTime, itemsDecoded: selected.length });
+                if (processor)
+                    await processor(decoded);
+                if (options.collect !== false) {
+                    if (splitByAddress)
+                        selected.forEach((row, i) => {
+                            var _a, _b, _c;
+                            for (const bucket of (_c = targetBuckets.get((_b = ((_a = row.source) !== null && _a !== void 0 ? _a : row.address)) === null || _b === void 0 ? void 0 : _b.toLowerCase())) !== null && _c !== void 0 ? _c : [])
+                                collected[bucket].push(decoded[i]);
+                        });
+                    else
+                        safePush(collected, decoded);
+                }
+            }
+            if (remainingLimit <= 0)
+                throw finished;
+        }
+        const rawOptions = {
+            ...options, chain, topic, topics, target: undefined, targets: uniqueTargets,
+            eventAbi: undefined, parseLog: false, entireLog: true, onlyArgs: false,
+            flatten: true, onDecodeStats: undefined,
+        };
+        try {
+            if (breakBlock >= fromBlock) {
+                await getLogs({
+                    ...rawOptions, fromBlock, toBlock: breakBlock, all: true, offset: 0, collect: false,
+                    processor: rows => consume(rows, true, fromBlock, breakBlock),
+                });
+            }
+            // RPC cache reads may extend the physical fetch by a buffer, but logs.ts
+            // filters to these exact bounds before any decoding or processing here.
+            for (let start = breakBlock + 1; start <= toBlock; start += effectiveMaxBlockRange) {
+                const end = Math.min(toBlock, start + effectiveMaxBlockRange - 1);
+                const rows = await (0, logs_1.getLogs)({
+                    ...rawOptions, fromBlock: start, toBlock: end, skipIndexer: true,
+                    maxBlockRange: undefined, processor: undefined,
+                });
+                rows.sort((a, b) => { var _a, _b; return a.blockNumber - b.blockNumber || ((_a = a.logIndex) !== null && _a !== void 0 ? _a : a.index) - ((_b = b.logIndex) !== null && _b !== void 0 ? _b : b.index); });
+                await consume(rows, false, start, end);
+            }
+        }
+        catch (error) {
+            if (error !== finished)
+                throw error;
+        }
+        return collected;
+    }
 }
 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;
@@ -651,55 +703,27 @@ async function getTokenTransfers({ chain = "ethereum", fromAddressFilter, fromBl
         (0, debugLog_1.debugLog)("[Indexer] Pulling token transfers " + debugTimeKey);
         console.time(debugTimeKey);
     }
-    const useCursorPagination = supportsCursorPagination(indexerVersion) && all;
-    let currentOffset = useCursorPagination ? 0 : offset;
-    let remainingOffset = useCursorPagination ? offset : 0;
-    let hasMore = true;
-    let cursor;
-    do {
-        const params = {
-            addresses,
-            chainId,
-            from_block: fromBlock,
-            to_block: toBlock,
-            limit,
-            offset: currentOffset,
-            tokens,
-            from_address: false,
-            to_address: false,
-        };
-        if (useCursorPagination) {
-            params.includeTotal = false;
-            applyCursorParams(params, cursor);
-        }
-        switch (transferType) {
-            case "in":
-                params.to_address = true;
-                break;
-            case "out":
-                params.from_address = true;
-                break;
-            case "all":
-                params.from_address = true;
-                params.to_address = true;
-                break;
-            default:
-                throw new Error("Invalid transferType");
-        }
-        const { data: { transfers: _logs }, } = await axiosInstances[indexerVersion](`/token-transfers`, { params }).catch((e) => { throw (0, common_1.formError)(e); });
-        const nextCursor = useCursorPagination ? getTransferCursor(_logs[_logs.length - 1]) : undefined;
-        const offsetResult = useCursorPagination ? applyLocalOffset(_logs, remainingOffset) : { rows: _logs, remainingOffset };
-        remainingOffset = offsetResult.remainingOffset;
-        rawTransfers.push(...offsetResult.rows);
-        if (useCursorPagination && nextCursor) {
-            cursor = nextCursor;
-            currentOffset = 0;
-        }
-        else {
-            currentOffset += limit;
-        }
-        hasMore = _logs.length === limit;
-    } while (all && hasMore);
+    const params = {
+        addresses, chainId, from_block: fromBlock, to_block: toBlock, tokens,
+        from_address: false, to_address: false,
+    };
+    switch (transferType) {
+        case "in":
+            params.to_address = true;
+            break;
+        case "out":
+            params.from_address = true;
+            break;
+        case "all":
+            params.from_address = true;
+            params.to_address = true;
+            break;
+        default:
+            throw new Error("Invalid transferType");
+    }
+    for await (const rows of getIndexerPages(indexerVersion, "/token-transfers", "transfers", params, limit, offset, all, getTransferCursor)) {
+        safePush(rawTransfers, rows);
+    }
     const filteredTransfers = rawTransfers.filter((l) => {
         if (!fromFilterEnabled)
             return true;
@@ -766,7 +790,22 @@ async function getTransactions({ chain = "ethereum", addresses, transaction_hash
         (0, debugLog_1.debugLog)("[Indexer] Pulling transactions " + debugTimeKey);
         console.time(debugTimeKey);
     }
-    const { data: { transactions } } = await axiosInstances[indexerVersion](`/transactions`, { params }).catch((e) => { throw (0, common_1.formError)(e); });
+    let transactions;
+    if (indexerVersion === "v4") {
+        transactions = [];
+        // all=false with limit=0 historically omitted limit (server default 1000).
+        const requestedLimit = typeof limit === "number" && limit > 0 ? limit : 1000;
+        // v2 ignores limit when all=true. Preserve that public contract without
+        // turning a small caller limit into hundreds of v4 network round trips.
+        const pageLimit = all ? Math.max(1000, requestedLimit) : requestedLimit;
+        for await (const rows of getV4Pages("/transactions", "transactions", params, pageLimit, offset, all, getTransactionCursor)) {
+            safePush(transactions, rows);
+        }
+    }
+    else {
+        const { data } = await axiosInstances.v2('/transactions', { params }).catch((e) => { throw (0, common_1.formError)(e); });
+        transactions = data.transactions;
+    }
     if (debugMode) {
         console.timeEnd(debugTimeKey);
         (0, debugLog_1.debugLog)("Transactions pulled " + chain, addresses || transaction_hashes, (transactions === null || transactions === void 0 ? void 0 : transactions.length) || 0);