@defillama/sdk 5.0.146 → 5.0.148

package/build/util/indexer.js

@@ -3,9 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTransactions = exports.getTokenTransfers = exports.isIndexer2Enabled = exports.isIndexerEnabled = exports.getLogs = exports.getTokens = exports.supportedChainSet2 = exports.supportedChainSet = void 0;
+exports.isIndexer2Enabled = exports.isIndexerEnabled = exports.getTransactions = exports.getTokenTransfers = exports.getLogs = exports.getTokens = exports.supportedChainSet2 = exports.supportedChainSet = void 0;
 const axios_1 = __importDefault(require("axios"));
-const ethers_1 = require("ethers");
 const _1 = require(".");
 const general_1 = require("../general");
 const generalUtil_1 = require("../generalUtil");
@@ -14,74 +13,51 @@ const cache_1 = require("./cache");
 const debugLog_1 = require("./debugLog");
 const env_1 = require("./env");
 const logs_1 = require("./logs");
-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');
+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 indexerChainIdChainMapping = {
-    1: 'ethereum',
-    10: 'optimism',
-    56: 'bsc',
-    100: 'xdai',
-    137: 'polygon',
-    204: 'op_bnb',
-    250: 'fantom',
-    324: 'era',
-    1101: 'polygon_zkevm',
-    8453: 'base',
-    34443: 'mode',
-    42170: 'arbitrum_nova',
-    42161: 'arbitrum',
-    43114: 'avax',
-    59144: 'linea',
-    81457: 'blast',
-    534352: 'scroll',
-    146: 'sonic',
+    1: "ethereum",
+    10: "optimism",
+    56: "bsc",
+    100: "xdai",
+    137: "polygon",
+    204: "op_bnb",
+    250: "fantom",
+    324: "era",
+    1101: "polygon_zkevm",
+    8453: "base",
+    34443: "mode",
+    42170: "arbitrum_nova",
+    42161: "arbitrum",
+    43114: "avax",
+    59144: "linea",
+    81457: "blast",
+    534352: "scroll",
+    146: "sonic",
 };
+// v2 chains (superset of v1)
 const indexer2ChainIdChainMapping = {
     ...indexerChainIdChainMapping,
-    130: 'unichain',
-    1868: 'soneium',
-    80094: 'berachain',
-    999: 'hyperliquid'
+    130: "unichain",
+    1868: "soneium",
+    80094: "berachain",
+    999: "hyperliquid",
 };
-const state = { chainIndexStatus: {} };
-const cacheTime = 1 * 60 * 1000; // 1 minutes - we cache sync status for 1 minute
-async function getChainIndexStatus(version = 'v1') {
-    checkIndexerConfig(version);
-    if (state.timestamp && (Date.now() - state.timestamp) < cacheTime)
-        return state.chainIndexStatus;
-    state.timestamp = Date.now();
-    state.chainIndexStatus = _getState();
-    return state.chainIndexStatus;
-    async function _getState() {
-        const { data: { syncStatus } } = await axiosInstances[version].get(`/sync`);
-        const syncInfo = {};
-        syncStatus.forEach((d) => {
-            const chain = indexerConfigs[version].chainMapping[d.chain];
-            if (chain) {
-                syncInfo[chain] = {
-                    block: d.lastIndexedBlock,
-                    timestamp: +new Date(d.lastIndexedDate)
-                };
-            }
-        });
-        state.chainIndexStatus = syncInfo;
-        return syncInfo;
-    }
-}
 const indexerConfigs = {
     v1: {
         endpoint: indexerURL,
         apiKey: LLAMA_INDEXER_API_KEY,
-        chainMapping: indexerChainIdChainMapping
+        chainMapping: indexerChainIdChainMapping,
     },
     v2: {
         endpoint: LLAMA_INDEXER_V2_ENDPOINT,
         apiKey: LLAMA_INDEXER_V2_API_KEY,
-        chainMapping: indexer2ChainIdChainMapping
-    }
+        chainMapping: indexer2ChainIdChainMapping,
+    },
 };
 const axiosInstances = {
     v1: axios_1.default.create({
@@ -91,53 +67,83 @@ const axiosInstances = {
     v2: axios_1.default.create({
         headers: { "x-api-key": indexerConfigs.v2.apiKey },
         baseURL: indexerConfigs.v2.endpoint,
-    })
+    }),
 };
 function checkIndexerConfig(version) {
     const config = indexerConfigs[version];
     if (!config.endpoint || !config.apiKey)
         throw new Error(`Llama Indexer ${version} URL/api key is not set`);
 }
-function getChainId(chain, version = 'v1') {
+function getChainId(chain, version = "v2") {
     var _a;
-    const chainId = (_a = Object.entries(indexerConfigs[version].chainMapping)
-        .find(([_, chainName]) => chainName === chain)) === null || _a === void 0 ? void 0 : _a[0];
+    const chainId = (_a = Object.entries(indexerConfigs[version].chainMapping).find(([, chainName]) => chainName === chain)) === null || _a === void 0 ? void 0 : _a[0];
     if (!chainId)
-        throw new Error('Chain not supported');
+        throw new Error("Chain not supported");
     return +chainId;
 }
-function getSupportedChains(version = 'v1') {
+function getSupportedChains(version = "v2") {
     return new Set(Object.values(indexerConfigs[version].chainMapping));
 }
-exports.supportedChainSet = getSupportedChains('v1');
-exports.supportedChainSet2 = getSupportedChains('v2');
+exports.supportedChainSet = getSupportedChains("v1"); // legacy
+exports.supportedChainSet2 = getSupportedChains("v2");
 const chainToIDMapping = {};
 Object.entries(indexerConfigs.v1.chainMapping).forEach(([id, chain]) => {
-    chainToIDMapping[chain] = id;
+    chainToIDMapping[chain] = +id;
 });
 const chainToIDMapping2 = {};
 Object.entries(indexerConfigs.v2.chainMapping).forEach(([id, chain]) => {
-    chainToIDMapping2[chain] = id;
+    chainToIDMapping2[chain] = +id;
 });
+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)
+        return state.chainIndexStatus;
+    state.timestamp = Date.now();
+    state.chainIndexStatus = (async () => {
+        const { data: { syncStatus }, } = await axiosInstances[version].get(`/sync`);
+        const info = {};
+        syncStatus.forEach((d) => {
+            const chain = indexerConfigs[version].chainMapping[d.chain];
+            if (chain) {
+                info[chain] = {
+                    block: d.lastIndexedBlock,
+                    timestamp: +new Date(d.lastIndexedDate),
+                };
+            }
+        });
+        return (state.chainIndexStatus = info);
+    })();
+    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');
+    checkIndexerConfig("v1");
     if (!address)
-        throw new Error('Address is required either as a string or an array of strings');
+        throw new Error("Address is required either as a string or an array of strings");
     if (Array.isArray(address) && !address.length)
-        throw new Error('Address array cannot be empty');
+        throw new Error("Address array cannot be empty");
     if (Array.isArray(address))
-        address = address.join(',');
+        address = address.join(",");
     address = address.toLowerCase();
     let chainId;
     if (chain)
         chainId = chainToIDMapping[chain];
-    const project = 'llama-indexer-cache';
+    const project = "llama-indexer-cache";
     const key = onlyWhitelisted ? address : `${address}/all`;
     const file = `${project}/${key}`;
     const timeNow = Math.floor(Date.now() / 1e3);
@@ -145,28 +151,29 @@ async function getTokens(address, { onlyWhitelisted = true, skipCacheRead = fals
     let cache = {};
     if (!skipCacheRead && !skipCache) {
         cache = (_a = (await (0, cache_1.readCache)(file))) !== null && _a !== void 0 ? _a : {};
-        if (cache.timestamp && (timeNow - cache.timestamp) < THREE_DAYS)
+        if (cache.timestamp && timeNow - cache.timestamp < THREE_DAYS)
             return cache.tokens;
     }
-    (0, debugLog_1.debugLog)('[Indexer] Pulling tokens for ' + address);
+    (0, debugLog_1.debugLog)("[Indexer] Pulling tokens for " + address);
     const tokens = (_b = cache.tokens) !== null && _b !== void 0 ? _b : {};
-    const { data: { balances } } = await axiosInstances.v1(`/balances`, {
+    const { data: { balances }, } = await axiosInstances.v1(`/balances`, {
         params: {
             addresses: address,
             chainId,
             type: tokenType,
         },
     });
-    balances.filter((b) => +b.total_amount > 0).forEach((b) => {
+    balances
+        .filter((b) => +b.total_amount > 0)
+        .forEach((b) => {
         const chain = indexerConfigs.v1.chainMapping[b.chain];
-        if (!chain) {
+        if (!chain)
             return;
-        }
         if (!tokens[chain])
             tokens[chain] = [];
         tokens[chain].push(b.address);
     });
-    const tokenCache = { timestamp: timeNow, tokens, };
+    const tokenCache = { timestamp: timeNow, tokens };
     Object.entries(tokens).forEach(([chain, values]) => {
         values.push(general_1.ETHER_ADDRESS);
         tokens[chain] = (0, generalUtil_1.getUniqueAddresses)(values);
@@ -176,239 +183,188 @@ async function getTokens(address, { onlyWhitelisted = true, skipCacheRead = fals
     return tokens;
 }
 exports.getTokens = getTokens;
-async function getIndexerVersionForBlock(chain, blockNumber) {
-    var _a, _b;
-    if (!isIndexer2Enabled(chain)) {
-        if (!isIndexerEnabled(chain)) {
-            throw new Error(`Indexer not enabled for chain ${chain}`);
-        }
-        return 'v1';
-    }
-    const syncStatus = await getChainIndexStatus('v2');
-    const lastIndexedBlock = (_b = (_a = syncStatus[chain]) === null || _a === void 0 ? void 0 : _a.block) !== null && _b !== void 0 ? _b : 0;
-    if (lastIndexedBlock >= blockNumber) {
-        return 'v2';
-    }
-    return 'v1';
-}
-async function executeWithFallback(chain, blockNumber, v2Fn, v1Fn) {
-    const version = await getIndexerVersionForBlock(chain, blockNumber);
-    try {
-        return version === 'v2' ? await v2Fn() : await v1Fn();
-    }
-    catch (error) {
-        if (version === 'v2') {
-            console.log(`Fallback to v1 for chain ${chain} due to error:`, error);
-            return v1Fn();
-        }
-        throw error;
-    }
-}
-async function getLogs({ chain = 'ethereum', topic, topics, fromBlock, toBlock, all = true, limit = 1000, offset = 0, target, targets, eventAbi, entireLog = false, flatten = true, extraTopics, fromTimestamp, toTimestamp, debugMode = false, noTarget = false, parseLog = true, }) {
+// ---------------------------------------------------------------------------
+// LOGS (v2 only)
+// ---------------------------------------------------------------------------
+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;
+    const { chain, fromBlock, toBlock, topic, topic1, topic2, topic3, transformLog, } = await (0, logs_1.getLogParams)(options, true);
     if (!debugMode)
         debugMode = debugLog_1.DEBUG_LEVEL2;
-    const version = await getIndexerVersionForBlock(chain, toBlock !== null && toBlock !== void 0 ? toBlock : 0);
-    checkIndexerConfig(version);
-    const chainId = getChainId(chain, version);
-    let topic1;
-    let topic2;
-    let topic3;
-    if (((topics === null || topics === void 0 ? void 0 : topics.length) && topics.length > 1)) {
-        if (topics === null || topics === void 0 ? void 0 : topics.length) {
-            topic1 = topics[1];
-            topic2 = topics[2];
-            topic3 = topics[3];
-        }
+    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.");
     }
-    else if (extraTopics === null || extraTopics === void 0 ? void 0 : extraTopics.length) {
-        topic1 = extraTopics[0];
-        topic2 = extraTopics[1];
-        topic3 = extraTopics[2];
+    // We now only support v2 for logs ---------------------------------------------------------
+    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) {
+        throw new Error(`Indexer not up to date for ${chain}. Last indexed block: ${lastIndexedBlock}, requested block: ${toBlock}`);
     }
-    if (topics === null || topics === void 0 ? void 0 : topics.length)
-        topic = topics[0];
-    if (!eventAbi)
-        entireLog = true;
-    if (!noTarget && !target && !(targets === null || targets === void 0 ? void 0 : targets.length))
-        throw new Error('target|targets is required or set the flag "noTarget" to true');
-    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 (version === 'v1') {
-        const chainIndexStatus = await getChainIndexStatus('v1');
-        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}`);
+    // 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);
+        }
+        if (flatten || !(targets === null || targets === void 0 ? void 0 : targets.length))
+            return results.flat();
+        return targets.map((_, i) => results.map((r) => r[i]).flat());
     }
+    // -------------------------------------------------------------------------
+    // Prepare address filters
+    // -------------------------------------------------------------------------
     let address = target;
-    if (typeof target === 'string')
+    if (typeof target === "string")
         targets = [target];
-    if (Array.isArray(targets))
-        address = targets.join(',');
-    const hasAddressFilter = address && address.length;
+    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();
-    // Create an Interface object
-    let iface;
-    if (eventAbi)
-        iface = new ethers_1.Interface([eventAbi]);
-    if (topic)
-        topic = (0, logs_1.toFilterTopic)(topic);
-    else if (eventAbi)
-        topic = (0, logs_1.toFilterTopic)(eventAbi);
-    let hasMore = true;
-    let logs = [];
+    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);
+    // -------------------------------------------------------------------------
+    // Pull logs
+    // -------------------------------------------------------------------------
+    const allLogs = [];
     const debugTimeKey = `Indexer-getLogs-${chain}-${topic}-${address}_${Math.random()}`;
     if (debugMode) {
-        (0, debugLog_1.debugLog)('[Indexer] Pulling logs ' + debugTimeKey);
+        (0, debugLog_1.debugLog)("[Indexer] Pulling logs " + debugTimeKey);
         console.time(debugTimeKey);
     }
-    const addressSet = new Set(address === null || address === void 0 ? void 0 : address.split(','));
-    const addressChunks = (0, _1.sliceIntoChunks)((_c = address === null || address === void 0 ? void 0 : address.split(',')) !== null && _c !== void 0 ? _c : [], addressChunkSize);
-    // to ensure that we have at least one chunk to process if no target is provided
-    if (noTarget && addressChunks.length === 0)
-        addressChunks.push(undefined);
     for (const chunk of addressChunks) {
-        if (Array.isArray(chunk) && chunk.length === 0) {
-            throw new Error('Address chunk cannot be empty');
-        }
+        if (Array.isArray(chunk) && chunk.length === 0)
+            throw new Error("Address chunk cannot be empty");
+        let chunkOffset = initialOffset;
         let logCount = 0;
+        let hasMore = true;
         do {
             const params = {
-                addresses: hasAddressFilter ? chunk.join(',') : undefined,
+                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,
+                topic1,
+                topic2,
+                topic3,
+                limit,
+                offset: chunkOffset,
                 noTarget,
+                eventAbi: options.eventAbi,
+                parseLog: options.parseLog,
+                onlyArgs: options.onlyArgs,
             };
-            const { data: { logs: _logs, totalCount } } = await executeWithFallback(chain, toBlock, () => axiosInstances.v2(`/logs`, { params }), () => axiosInstances.v1(`/logs`, { params }));
-            // getLogs uses 'address' field to return log source, so we add the field here to make it compatible
-            _logs.forEach((l) => {
-                l.address = l.source;
-                const iswhitelisted = !addressSet.size || addressSet.has(l.source.toLowerCase());
-                if (iswhitelisted) {
-                    logs.push(l);
+            const { data: { logs: _logs, totalCount }, } = await axiosInstances.v2(`/logs`, { params });
+            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;
             });
+            // 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) }));
+            if (processor)
+                await processor(transformed.map((i) => i.transformed));
+            allLogs.push(...transformed);
             logCount += _logs.length;
-            offset += limit;
-            // If we have all the logs, or we have reached the limit, or there are no logs, we stop
+            chunkOffset += limit;
             if (_logs.length < limit || totalCount <= logCount || _logs.length === 0)
                 hasMore = false;
         } while (all && hasMore);
     }
     if (debugMode) {
         console.timeEnd(debugTimeKey);
-        (0, debugLog_1.debugLog)('Logs pulled ' + chain, address, logs.length);
+        (0, debugLog_1.debugLog)("Logs pulled " + chain, address, allLogs.length);
     }
-    const mappedLogs = [];
-    let addressIndexMap = {};
+    // -------------------------------------------------------------------------
+    // Map / transform result
+    // -------------------------------------------------------------------------
     const splitByAddress = (targets === null || targets === void 0 ? void 0 : targets.length) && !flatten;
     if (splitByAddress) {
-        for (let i = 0; i < targets.length; i++) {
-            addressIndexMap[targets[i].toLowerCase()] = i;
-            mappedLogs.push([]);
-        }
+        const mapped = targets.map(() => []);
+        const indexMap = {};
+        targets.forEach((t, i) => (indexMap[t.toLowerCase()] = i));
+        allLogs.forEach(({ raw, transformed }) => {
+            const idx = indexMap[raw.source.toLowerCase()];
+            if (idx === undefined)
+                return; // ignore unknown sources
+            mapped[idx].push(transformed);
+        });
+        return mapped;
     }
-    logs = logs.map((log) => {
-        const source = log.source.toLowerCase();
-        log.logIndex = log.log_index;
-        log.index = log.log_index;
-        log.transactionHash = log.transaction_hash;
-        log.blockNumber = log.block_number;
-        log.topics = [log.topic0, log.topic1, log.topic2, log.topic3,].filter(t => t !== '').map(i => ethers_1.ethers.zeroPadValue(i, 32));
-        const deleteKeys = ['chain', 'block_number', 'log_index', 'topic0', 'topic1', 'topic2', 'topic3', 'decodedArgs', 'transaction_hash',];
-        deleteKeys.forEach(k => delete log[k]);
-        const parsedLog = iface === null || iface === void 0 ? void 0 : iface.parseLog({ data: log.data, topics: log.topics, });
-        log.args = parsedLog === null || parsedLog === void 0 ? void 0 : parsedLog.args;
-        log = !entireLog ? log.args : log;
-        if (entireLog && parseLog)
-            log.parsedLog = parsedLog;
-        if (splitByAddress) {
-            const index = addressIndexMap[source];
-            mappedLogs[index].push(log);
-        }
-        return log;
-    });
-    if (splitByAddress)
-        return mappedLogs;
-    return logs;
+    return allLogs.map(i => i.transformed);
 }
 exports.getLogs = getLogs;
-function isIndexerEnabled(chain) {
-    if (!indexerConfigs.v1.endpoint)
-        return false;
-    if (chain && !exports.supportedChainSet.has(chain))
-        return false;
-    return true;
-}
-exports.isIndexerEnabled = isIndexerEnabled;
-function isIndexer2Enabled(chain) {
-    if (!indexerConfigs.v2.endpoint)
-        return false;
-    if (chain && !exports.supportedChainSet2.has(chain))
-        return false;
-    return true;
-}
-exports.isIndexer2Enabled = isIndexer2Enabled;
-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, }) {
+// ---------------------------------------------------------------------------
+// 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;
-    const version = await getIndexerVersionForBlock(chain, toBlock !== null && toBlock !== void 0 ? toBlock : 0);
-    checkIndexerConfig(version);
-    const chainId = getChainId(chain, version);
-    const fromFilterEnabled = fromAddressFilter && fromAddressFilter.length;
-    if (fromAddressFilter && typeof fromAddressFilter === 'string')
+    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];
     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');
+        throw new Error("fromBlock or fromTimestamp is required");
     if (!toBlock && !toTimestamp)
-        throw new Error('toBlock or toTimestamp is required');
+        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');
+        throw new Error("fromBlock and toBlock must be > 0");
     if (token)
         tokens = [token];
     if (tokens) {
-        if (typeof tokens === 'string')
+        if (typeof tokens === "string")
             tokens = [tokens];
-        tokens = tokens.join(',').toLowerCase();
+        tokens = tokens.join(",").toLowerCase();
     }
     if (target)
         targets = [target];
     if (!targets.length)
-        throw new Error('target|targets is required');
-    targets = targets.map(t => t.toLowerCase());
-    let addresses = targets.join(',');
-    if (version === 'v1') {
-        const chainIndexStatus = await getChainIndexStatus('v1');
-        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}`);
+        throw new Error("target|targets is required");
+    targets = targets.map((t) => t.toLowerCase());
+    const addresses = targets.join(",");
+    // 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}`);
     }
-    let hasMore = true;
-    let logs = [];
+    // -----------------------------------------------------------------------
+    // Fetch transfers
+    // -----------------------------------------------------------------------
+    const rawTransfers = [];
     const debugTimeKey = `Indexer-tokenTransfers-${chain}-${addresses}_${Math.random()}`;
     if (debugMode) {
-        (0, debugLog_1.debugLog)('[Indexer] Pulling token transfers ' + debugTimeKey);
+        (0, debugLog_1.debugLog)("[Indexer] Pulling token transfers " + debugTimeKey);
         console.time(debugTimeKey);
     }
+    let currentOffset = offset;
+    let hasMore = true;
     do {
         const params = {
             addresses,
@@ -416,161 +372,149 @@ async function getTokenTransfers({ chain = 'ethereum', fromAddressFilter, fromBl
             from_block: fromBlock,
             to_block: toBlock,
             limit,
-            offset,
+            offset: currentOffset,
             tokens,
             from_address: false,
             to_address: false,
         };
         switch (transferType) {
-            case 'in':
+            case "in":
                 params.to_address = true;
                 break;
-            case 'out':
+            case "out":
                 params.from_address = true;
                 break;
-            case 'all':
+            case "all":
                 params.from_address = true;
                 params.to_address = true;
                 break;
             default:
-                throw new Error('Invalid transferType');
+                throw new Error("Invalid transferType");
         }
-        const { data: { transfers: _logs, totalCount } } = await executeWithFallback(chain, toBlock, () => axiosInstances.v2(`/token-transfers`, { params }), () => axiosInstances.v1(`/token-transfers`, { params }));
-        logs.push(..._logs);
-        offset += limit;
-        // If we have all the logs, or we have reached the limit, or there are no logs, we stop
-        if (_logs.length < limit || totalCount <= logs.length || _logs.length === 0)
+        const { data: { transfers: _logs, totalCount }, } = await axiosInstances.v2(`/token-transfers`, { params });
+        rawTransfers.push(..._logs);
+        currentOffset += limit;
+        if (_logs.length < limit || totalCount <= rawTransfers.length || _logs.length === 0)
             hasMore = false;
     } while (all && hasMore);
-    logs = logs.filter((l) => {
+    const filteredTransfers = rawTransfers.filter((l) => {
         if (!fromFilterEnabled)
             return true;
-        return fromFilterSet.has(l === null || l === void 0 ? void 0 : l.from_address.toLowerCase());
+        return fromFilterSet.has(l.from_address.toLowerCase());
     });
     if (debugMode) {
         console.timeEnd(debugTimeKey);
-        (0, debugLog_1.debugLog)('Token Transfers pulled ' + chain, addresses, logs.length);
+        (0, debugLog_1.debugLog)("Token Transfers pulled " + chain, addresses, filteredTransfers.length);
     }
-    const mappedLogs = [];
-    let addressIndexMap = {};
+    // -----------------------------------------------------------------------
+    // Split result if requested
+    // -----------------------------------------------------------------------
     const splitByAddress = (targets === null || targets === void 0 ? void 0 : targets.length) && !flatten;
     if (splitByAddress) {
-        for (let i = 0; i < targets.length; i++) {
-            addressIndexMap[targets[i]] = i;
-            mappedLogs.push([]);
-        }
-    }
-    if (splitByAddress) {
-        logs.forEach((log) => {
-            const sourceField = transferType === 'in' ? 'to_address' : 'from_address';
-            const source = log[sourceField].toLowerCase();
-            const index = addressIndexMap[source];
-            mappedLogs[index].push(log);
+        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 mappedLogs;
+        return mapped;
     }
-    return logs;
+    return filteredTransfers;
 }
 exports.getTokenTransfers = getTokenTransfers;
-async function getTransactions({ chain = 'ethereum', addresses, transaction_hashes, from_block, to_block, all = true, limit = 1000, offset = 0, debugMode = false, transactionType = 'from' }) {
+// ---------------------------------------------------------------------------
+// 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)
         debugMode = debugLog_1.DEBUG_LEVEL2;
-    checkIndexerConfig('v2');
-    const chainId = getChainId(chain, 'v2');
-    if ((!addresses || addresses.length === 0) && (!transaction_hashes || transaction_hashes.length === 0)) {
+    checkIndexerConfig("v2");
+    const chainId = getChainId(chain, "v2");
+    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) {
+    if (!from_block || !to_block)
         throw new Error("'from_block' and 'to_block' are required to search for transactions");
-    }
-    const chainIndexStatus = await getChainIndexStatus('v2');
+    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 (to_block > lastIndexedBlock) {
         throw new Error(`Indexer not up to date for ${chain}. Last indexed block: ${lastIndexedBlock}, requested block: ${to_block}`);
     }
-    const apiParams = { chainId };
+    const params = { chainId };
     if (addresses) {
-        if (Array.isArray(addresses)) {
-            apiParams.addresses = addresses.map((a) => a.toLowerCase()).join(',');
-        }
-        else {
-            apiParams.addresses = addresses.toLowerCase();
-        }
+        params.addresses = Array.isArray(addresses)
+            ? addresses.map((a) => a.toLowerCase()).join(",")
+            : addresses.toLowerCase();
     }
     if (transaction_hashes) {
-        if (Array.isArray(transaction_hashes)) {
-            apiParams.transaction_hashes = transaction_hashes.map((h) => h.toLowerCase()).join(',');
-        }
-        else {
-            apiParams.transaction_hashes = transaction_hashes.toLowerCase();
-        }
+        params.transaction_hashes = Array.isArray(transaction_hashes)
+            ? transaction_hashes.map((h) => h.toLowerCase()).join(",")
+            : transaction_hashes.toLowerCase();
     }
-    apiParams.from_block = from_block;
-    apiParams.to_block = to_block;
+    params.from_block = from_block;
+    params.to_block = to_block;
     if (offset)
-        apiParams.offset = offset;
-    let from_address = false;
-    let to_address = false;
-    switch (transactionType) {
-        case 'from':
-            from_address = true;
-            break;
-        case 'to':
-            to_address = true;
-            break;
-        case 'all':
-        default:
-            from_address = true;
-            to_address = true;
-            break;
-    }
-    apiParams.from_address = from_address;
-    apiParams.to_address = to_address;
-    if (all) {
-        apiParams.limit = 'all';
-    }
-    else {
-        if (limit !== 'all' && limit !== 0) {
-            apiParams.limit = limit;
-        }
-    }
+        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);
+        (0, debugLog_1.debugLog)("[Indexer] Pulling transactions " + debugTimeKey);
         console.time(debugTimeKey);
     }
-    const { data: { transactions } } = await axiosInstances.v2(`/transactions`, {
-        params: apiParams,
-    });
+    const { data: { transactions } } = await axiosInstances.v2(`/transactions`, { params });
     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);
+        (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((transaction) => ({
-        hash: transaction.hash,
-        blockNumber: parseInt(transaction.block_number),
-        transactionIndex: parseInt(transaction.transaction_index),
-        from: transaction.from_address,
-        to: transaction.to_address,
-        value: transaction.value,
-        gasPrice: transaction.gas_price,
-        gas: transaction.gas,
-        input: transaction.input,
-        nonce: parseInt(transaction.nonce),
-        data: transaction.input,
-        type: transaction.transaction_type,
-        maxFeePerGas: transaction.max_fee_per_gas,
-        maxPriorityFeePerGas: transaction.max_priority_fee_per_gas,
-        baseFeePerGas: transaction.base_fee_per_gas,
-        effectiveGasPrice: transaction.effective_gas_price,
-        gasUsed: transaction.gas_used,
-        cumulativeGasUsed: transaction.cumulative_gas_used,
-        status: transaction.status === 'success' ? 1 : 0,
-        contractCreated: transaction.contract_created || undefined,
-        timestamp: transaction.timestamp,
+    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,
     }));
 }
 exports.getTransactions = getTransactions;
+// ---------------------------------------------------------------------------
+// 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))
+        return false;
+    return true;
+}
+exports.isIndexerEnabled = isIndexerEnabled;
+function isIndexer2Enabled(chain) {
+    // Alias – retained so external calls do not break
+    return isIndexerEnabled(chain);
+}
+exports.isIndexer2Enabled = isIndexer2Enabled;