@defillama/sdk 5.0.240 → 5.0.244

package/build/util/indexer.js

@@ -0,0 +1,854 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportedChainSet2 = void 0;
+exports.getChainIndexerVersion = getChainIndexerVersion;
+exports.getLogs = getLogs;
+exports.getTokenTransfers = getTokenTransfers;
+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 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");
+const _1 = require(".");
+const blocks_1 = require("./blocks");
+const common_1 = require("./common");
+const callStats_1 = require("./callStats");
+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") !== "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 = {
+    1: "ethereum",
+    10: "optimism",
+    56: "bsc",
+    100: "xdai",
+    137: "polygon",
+    204: "op_bnb",
+    324: "era",
+    1101: "polygon_zkevm",
+    8453: "base",
+    34443: "mode",
+    42170: "arbitrum_nova",
+    42161: "arbitrum",
+    43114: "avax",
+    59144: "linea",
+    81457: "blast",
+    534352: "scroll",
+    146: "sonic",
+    130: "unichain",
+    1868: "soneium",
+    80094: "berachain",
+    999: "hyperliquid",
+    143: "monad",
+    4326: "megaeth",
+    196: "xlayer"
+};
+const v4OnlyChainIdChainMapping = {
+    4663: "robinhood",
+};
+((_b = (0, env_1.getEnvValue)("LLAMA_INDEXER_V4_ONLY_CHAINS")) !== null && _b !== void 0 ? _b : "")
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+    .forEach((entry) => {
+    const [chainId, chainName] = entry.split(":").map((i) => i.trim());
+    if (!chainId || !chainName || isNaN(+chainId))
+        throw new Error(`Invalid LLAMA_INDEXER_V4_ONLY_CHAINS entry: ${entry}`);
+    v4OnlyChainIdChainMapping[+chainId] = chainName;
+});
+const allChainIdChainMapping = { ...indexerChainIdChainMapping, ...v4OnlyChainIdChainMapping };
+const v4OnlyChainSet = new Set(Object.values(v4OnlyChainIdChainMapping));
+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 },
+};
+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 });
+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`);
+}
+// Prefer a configured v4 deployment; retain v2-only installations and explicit rollback.
+function getChainIndexerVersion(chain) {
+    if (v4OnlyChainSet.has(chain))
+        return "v4";
+    if (!LLAMA_INDEXER_V4_ENDPOINT)
+        return "v2";
+    if (LLAMA_INDEXER_PREFER_V4 || !LLAMA_INDEXER_V2_ENDPOINT)
+        return "v4";
+    return "v2";
+}
+function getChainId(chain) {
+    var _a;
+    const chainId = (_a = Object.entries(allChainIdChainMapping).find(([, chainName]) => chainName === chain)) === null || _a === void 0 ? void 0 : _a[0];
+    if (!chainId)
+        throw new Error("Chain not supported");
+    return +chainId;
+}
+exports.supportedChainSet2 = new Set(Object.values(allChainIdChainMapping));
+function getLogCursor(log) {
+    var _a, _b, _c;
+    if (!log)
+        return undefined;
+    const afterBlock = (_a = log.block_number) !== null && _a !== void 0 ? _a : log.blockNumber;
+    const afterIndex = (_c = (_b = log.log_index) !== null && _b !== void 0 ? _b : log.logIndex) !== null && _c !== void 0 ? _c : log.index;
+    if (afterBlock === undefined || afterIndex === undefined)
+        return undefined;
+    return { after_block: +afterBlock, after_index: +afterIndex };
+}
+function getTransferCursor(transfer) {
+    const cursor = getLogCursor(transfer);
+    if (!cursor)
+        return undefined;
+    if (transfer.id !== undefined && transfer.id !== null)
+        cursor.after_id = String(transfer.id);
+    return cursor;
+}
+function getTransactionCursor(transaction) {
+    if (!transaction)
+        return;
+    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)
+        return { rows, remainingOffset };
+    if (remainingOffset >= rows.length)
+        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: {} },
+};
+const cacheTime = 1 * 60 * 1000; // 1 min
+async function getChainIndexStatus(version) {
+    checkIndexerConfig(version);
+    const state = syncStates[version];
+    if (state.timestamp && Date.now() - state.timestamp < cacheTime)
+        return state.chainIndexStatus;
+    state.timestamp = Date.now();
+    state.chainIndexStatus = (async () => {
+        const { data: { syncStatus }, } = await axiosInstances[version].get(`/sync`).catch((e) => { throw (0, common_1.formError)(e); });
+        const info = {};
+        syncStatus.forEach((d) => {
+            const chain = allChainIdChainMapping[d.chain];
+            if (chain) {
+                info[chain] = {
+                    block: d.lastIndexedBlock,
+                    timestamp: +new Date(d.lastIndexedDate),
+                };
+            }
+        });
+        return (state.chainIndexStatus = info);
+    })().catch((error) => {
+        state.timestamp = undefined;
+        state.chainIndexStatus = {};
+        throw error;
+    });
+    return state.chainIndexStatus;
+}
+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: INDEXER_REQUEST_TIMEOUT_MS,
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity,
+        headers: { Accept: "application/json", "Accept-Encoding": "gzip" },
+        signal: controller.signal,
+    }).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;
+            }
+        }, (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 (shouldStop === null || shouldStop === void 0 ? void 0 : shouldStop()) {
+                    stopped = true;
+                    controller.abort();
+                    break;
+                }
+            }
+        });
+    }
+    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;
+    });
+}
+async function getLogs(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 = { ...options, collect: false };
+    }
+    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)
+        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;
+    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.");
+    }
+    // Ensure the indexer is synced far enough
+    const indexerVersion = getChainIndexerVersion(chain);
+    // one logical getLogs query against the indexer (chunks over maxBlockRange recurse here and count separately)
+    if (blockRange <= effectiveMaxBlockRange)
+        (0, callStats_1.recordMethod)('indexerGetLogs', chain);
+    checkIndexerConfig(indexerVersion);
+    const chainId = getChainId(chain);
+    const chainIndexStatus = await getChainIndexStatus(indexerVersion);
+    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.`);
+        // 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) {
+            const currentToBlock = Math.min(currentFromBlock + effectiveMaxBlockRange - 1, toBlock);
+            const chunk = await getLogs({ ...options, fromBlock: currentFromBlock, toBlock: currentToBlock });
+            results.push(chunk);
+        }
+        const splitTargets = typeof target === "string" ? [target] : targets;
+        if (flatten || !splitTargets.length)
+            return results.flat();
+        return splitTargets.map((_, i) => results.map((r) => r[i]).flat());
+    }
+    let address = target;
+    if (typeof target === "string")
+        targets = [target];
+    if (Array.isArray(targets) && targets.length)
+        address = targets.join(",");
+    const hasAddressFilter = !!(address === null || address === void 0 ? void 0 : address.length);
+    if (address)
+        address = address.toLowerCase();
+    const addressSet = new Set((address !== null && address !== void 0 ? address : "").split(",").filter(Boolean));
+    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);
+    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 = (_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);
+        const splitByAddress = (targets === null || targets === void 0 ? void 0 : targets.length) && !flatten;
+        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();
+            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 && options.collect !== false) {
+                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) {
+                safePush(collected, transformedLogs);
+            }
+        };
+        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;
+            await streamLogs({
+                path: `/logs?${qs.toString()}`,
+                version: indexerVersion,
+                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;
+                    if (remainingOffset > 0) {
+                        remainingOffset--;
+                        return;
+                    }
+                    if (remainingLimit <= 0) {
+                        stopNow = true;
+                        return;
+                    }
+                    transformBatch.push(raw);
+                    remainingLimit--;
+                    if (remainingLimit <= 0)
+                        stopNow = true;
+                    if (transformBatch.length >= MICRO_BATCH_SIZE) {
+                        const batch = transformBatch.splice(0, MICRO_BATCH_SIZE);
+                        await flushBatch(batch);
+                    }
+                },
+                shouldStop: () => stopNow,
+                onChunkStats: onWireStats,
+            });
+            if (transformBatch.length > 0) {
+                await flushBatch(transformBatch.splice(0, transformBatch.length));
+            }
+            if (remainingLimit <= 0)
+                break;
+        }
+        if (debugMode) {
+            const ms = Date.now() - start;
+            (0, debugLog_1.debugLog)(`[Indexer] stream finished: ${collected.length} items in ${ms}ms`);
+        }
+        if (splitByAddress) {
+            return addressBuckets;
+        }
+        return collected;
+    }
+    const allLogsPairs = [];
+    const debugTimeKey = `Indexer-getLogs-${chain}-${topic}-${address}_${Math.random()}`;
+    if (debugMode) {
+        (0, debugLog_1.debugLog)("[Indexer] Pulling logs " + debugTimeKey);
+        console.time(debugTimeKey);
+    }
+    for (const chunk of addressChunks) {
+        if (Array.isArray(chunk) && chunk.length === 0)
+            throw new Error("Address chunk cannot be empty");
+        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();
+            for (const log of filtered) {
+                (0, logs_decode_shared_1.normalizeLog)(log, true);
+            }
+            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(transformedPair.map((i) => i.transformed));
+            if (options.collect !== false) {
+                safePush(allLogsPairs, transformedPair);
+            }
+        }
+    }
+    if (debugMode) {
+        console.timeEnd(debugTimeKey);
+        (0, debugLog_1.debugLog)("Logs pulled " + chain, address, allLogsPairs.length);
+    }
+    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));
+        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 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;
+    if (!debugMode)
+        debugMode = debugLog_1.DEBUG_LEVEL2 && !!env_1.ENV_CONSTANTS.GET_LOGS_INDEXER;
+    const indexerVersion = getChainIndexerVersion(chain);
+    checkIndexerConfig(indexerVersion);
+    const chainId = getChainId(chain);
+    const fromFilterEnabled = !!(fromAddressFilter === null || fromAddressFilter === void 0 ? void 0 : fromAddressFilter.length);
+    if (typeof fromAddressFilter === "string")
+        fromAddressFilter = [fromAddressFilter];
+    const fromFilterSet = new Set((fromAddressFilter !== null && fromAddressFilter !== void 0 ? fromAddressFilter : []).map((a) => a.toLowerCase()));
+    if (!fromBlock && !fromTimestamp)
+        throw new Error("fromBlock or fromTimestamp is required");
+    if (!toBlock && !toTimestamp)
+        throw new Error("toBlock or toTimestamp is required");
+    if (!fromBlock)
+        fromBlock = await (0, blocks_1.getBlockNumber)(chain, fromTimestamp);
+    if (!toBlock)
+        toBlock = await (0, blocks_1.getBlockNumber)(chain, toTimestamp);
+    if (!fromBlock || !toBlock)
+        throw new Error("fromBlock and toBlock must be > 0");
+    if (token)
+        tokens = [token];
+    if (tokens) {
+        if (typeof tokens === "string")
+            tokens = [tokens];
+        if (!Array.isArray(tokens))
+            throw new Error("tokens must be a string or an array of strings");
+        tokens = tokens.join(",").toLowerCase();
+    }
+    if (target)
+        targets = [target];
+    if (!targets.length)
+        throw new Error("target|targets is required");
+    targets = targets.map((t) => t.toLowerCase());
+    const addresses = targets.join(",");
+    // Ensure the indexer is up-to-date
+    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;
+    if (lastIndexedBlock < toBlock) {
+        throw new Error(`Indexer not up to date for ${chain}. Last indexed block: ${lastIndexedBlock}, requested block: ${toBlock}`);
+    }
+    const rawTransfers = [];
+    const debugTimeKey = `Indexer-tokenTransfers-${chain}-${addresses}_${Math.random()}`;
+    if (debugMode) {
+        (0, debugLog_1.debugLog)("[Indexer] Pulling token transfers " + debugTimeKey);
+        console.time(debugTimeKey);
+    }
+    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;
+        return fromFilterSet.has(l.from_address.toLowerCase());
+    });
+    if (debugMode) {
+        console.timeEnd(debugTimeKey);
+        (0, debugLog_1.debugLog)("Token Transfers pulled " + chain, addresses, filteredTransfers.length);
+    }
+    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));
+        filteredTransfers.forEach((log) => {
+            const sourceField = transferType === "in" ? "to_address" : "from_address";
+            const idx = indexMap[log[sourceField].toLowerCase()];
+            if (idx !== undefined)
+                mapped[idx].push(log);
+        });
+        return mapped;
+    }
+    return filteredTransfers;
+}
+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)
+        debugMode = debugLog_1.DEBUG_LEVEL2 && !!env_1.ENV_CONSTANTS.GET_LOGS_INDEXER;
+    const indexerVersion = getChainIndexerVersion(chain);
+    checkIndexerConfig(indexerVersion);
+    const chainId = getChainId(chain);
+    if ((!addresses || addresses.length === 0) && (!transaction_hashes || transaction_hashes.length === 0))
+        throw new Error("You must provide at least 'addresses' or 'transaction_hashes'");
+    if (!from_block || !to_block)
+        throw new Error("'from_block' and 'to_block' are required to search for transactions");
+    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;
+    if (to_block > lastIndexedBlock) {
+        throw new Error(`Indexer not up to date for ${chain}. Last indexed block: ${lastIndexedBlock}, requested block: ${to_block}`);
+    }
+    const params = { chainId };
+    if (addresses) {
+        params.addresses = Array.isArray(addresses)
+            ? addresses.map((a) => a.toLowerCase()).join(",")
+            : addresses.toLowerCase();
+    }
+    if (transaction_hashes) {
+        params.transaction_hashes = Array.isArray(transaction_hashes)
+            ? transaction_hashes.map((h) => h.toLowerCase()).join(",")
+            : transaction_hashes.toLowerCase();
+    }
+    params.from_block = from_block;
+    params.to_block = to_block;
+    if (offset)
+        params.offset = offset;
+    params.from_address = transactionType !== "to";
+    params.to_address = transactionType !== "from";
+    if (all)
+        params.limit = "all";
+    else if (limit !== "all" && limit !== 0)
+        params.limit = limit;
+    const debugTimeKey = `Indexer-getTransactions-${chain}-${addresses || transaction_hashes}-${from_block}-${to_block}_${Math.random()}`;
+    if (debugMode) {
+        (0, debugLog_1.debugLog)("[Indexer] Pulling transactions " + debugTimeKey);
+        console.time(debugTimeKey);
+    }
+    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);
+    }
+    if (!(transactions === null || transactions === void 0 ? void 0 : transactions.length))
+        return null;
+    return transactions.map((t) => ({
+        hash: t.hash,
+        blockNumber: +t.block_number,
+        transactionIndex: +t.transaction_index,
+        from: t.from_address,
+        to: t.to_address,
+        value: t.value,
+        gasPrice: t.gas_price,
+        gas: t.gas,
+        input: t.input,
+        nonce: +t.nonce,
+        data: t.input,
+        type: t.transaction_type,
+        maxFeePerGas: t.max_fee_per_gas,
+        maxPriorityFeePerGas: t.max_priority_fee_per_gas,
+        baseFeePerGas: t.base_fee_per_gas,
+        effectiveGasPrice: t.effective_gas_price,
+        gasUsed: t.gas_used,
+        cumulativeGasUsed: t.cumulative_gas_used,
+        status: t.status === "success" ? 1 : 0,
+        contractCreated: t.contract_created || undefined,
+        timestamp: t.timestamp,
+    }));
+}
+function isIndexerEnabled(chain) {
+    if (!LLAMA_INDEXER_V2_ENDPOINT && !LLAMA_INDEXER_V4_ENDPOINT)
+        return false;
+    if (!chain)
+        return true;
+    if (!exports.supportedChainSet2.has(chain))
+        return false;
+    return !!indexerConfigs[getChainIndexerVersion(chain)].endpoint;
+}
+function isIndexer2Enabled(chain) {
+    return isIndexerEnabled(chain);
+}