@defillama/sdk 5.0.173 → 5.0.177

package/build/util/env.js

@@ -1,16 +1,35 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getChainRPCs = exports.getArchivalRPCs = exports.getBatchMaxCount = exports.getDefaultChunkSize = exports.getEnvMulticallAddress = exports.getEnvCacheFolder = exports.getEnvValue = exports.getEnvRPC = exports.getParallelGetBlocksLimit = exports.getParallelGetLogsLimit = exports.getMaxParallelRequests = exports.getChainId = exports.ENV_CONSTANTS = void 0;
+exports.ENV_CONSTANTS = exports.defaultShortenStringLength = exports.logGetLogsIndexer = exports.logGetLogsDebug = exports.logGetLogsErrors = exports.logGetBlockStats = void 0;
+exports.getChainId = getChainId;
+exports.getMaxParallelRequests = getMaxParallelRequests;
+exports.getParallelGetLogsLimit = getParallelGetLogsLimit;
+exports.getParallelGetBlocksLimit = getParallelGetBlocksLimit;
+exports.getEnvRPC = getEnvRPC;
+exports.getEnvValue = getEnvValue;
+exports.getEnvCacheFolder = getEnvCacheFolder;
+exports.getEnvMulticallAddress = getEnvMulticallAddress;
+exports.getDefaultChunkSize = getDefaultChunkSize;
+exports.getBatchMaxCount = getBatchMaxCount;
+exports.getArchivalRPCs = getArchivalRPCs;
+exports.getChainRPCs = getChainRPCs;
+exports.getWhitelistedRPCs = getWhitelistedRPCs;
 const whitelistedEnvConstants = [
     'R2_ENDPOINT', 'R2_ACCESS_KEY_ID', 'R2_SECRET_ACCESS_KEY', 'TRON_PRO_API_KEY', 'COINS_API_KEY',
     'ELASTICSEARCH_CONFIG', 'GRAPH_API_KEY', 'LLAMA_INDEXER_ENDPOINT', 'LLAMA_INDEXER_API_KEY', 'LLAMA_INDEXER_V2_ENDPOINT', 'LLAMA_INDEXER_V2_API_KEY',
 ];
+exports.logGetBlockStats = process.env.LLAMA_SDK_LOG_GET_BLOCK_STATS === 'true' || false;
+exports.logGetLogsErrors = process.env.LLAMA_SDK_LOG_GET_LOGS_ERRORS === 'true' || false;
+exports.logGetLogsDebug = process.env.LLAMA_SDK_LOG_GET_LOGS_DEBUG === 'true' || false;
+exports.logGetLogsIndexer = process.env.LLAMA_SDK_LOG_GET_LOGS_INDEXER === 'true' || false;
+exports.defaultShortenStringLength = +((_a = process.env.LLAMA_SDK_DEFAULT_SHORTEN_STRING_LENGTH) !== null && _a !== void 0 ? _a : '120');
 const defaultEnvValues = {
     INTERNAL_SDK_CACHE_FILE: './cache.json',
     TRON_RPC_CONCURRENCY_LIMIT: '5',
     LLAMA_INDEXER_ADDRESS_CHUNK_SIZE: '20',
-    TRON_RPC: 'https://api.trongrid.io',
-    TRON_EVM_RPC: 'https://rpc.ankr.com/tron_jsonrpc',
+    TRON_WALLET_RPC: 'https://api.trongrid.io',
+    // TRON_EVM_RPC: 'https://rpc.ankr.com/tron_jsonrpc', // no longer used
     NAKA_RPC: 'https://node.nakachain.xyz',
     ETHF_RPC: 'https://rpc.dischain.xyz/',
     CORE_RPC: "https://rpc.coredao.org,https://rpc.ankr.com/core,https://1rpc.io/core,https://rpc-core.icecreamswap.com",
@@ -33,7 +52,6 @@ function getChainId(chain, chainId) {
     const value = (_a = getEnvValue(`${chain}_RPC_CHAIN_ID`)) !== null && _a !== void 0 ? _a : chainId;
     return +value;
 }
-exports.getChainId = getChainId;
 function getMaxParallelRequests(chain) {
     const chainKey = `${chain}_RPC_MAX_PARALLEL`;
     if (getEnvValue(chainKey))
@@ -42,7 +60,6 @@ function getMaxParallelRequests(chain) {
         return 20;
     return +getEnvValue('MAX_PARALLEL', '100');
 }
-exports.getMaxParallelRequests = getMaxParallelRequests;
 function getParallelGetLogsLimit(chain, providerUrl) {
     let defaultLimit = getEnvValue('GET_LOGS_CONCURRENCY_LIMIT', '25');
     if (chain === 'fantom')
@@ -52,32 +69,26 @@ function getParallelGetLogsLimit(chain, providerUrl) {
         return +(defaultAlchemyLimit);
     return +(getEnvValue(`${chain}_RPC_GET_LOGS_CONCURRENCY_LIMIT`, defaultLimit));
 }
-exports.getParallelGetLogsLimit = getParallelGetLogsLimit;
 function getParallelGetBlocksLimit(chain) {
     const defaultLimit = getEnvValue('GET_BLOCKS_CONCURRENCY_LIMIT', '5');
     return +(getEnvValue(`${chain}_RPC_GET_BLOCKS_CONCURRENCY_LIMIT`, defaultLimit));
 }
-exports.getParallelGetBlocksLimit = getParallelGetBlocksLimit;
 function getEnvRPC(chain) {
     const key = `${chain}_RPC`.toUpperCase();
     return getEnvValue(key, defaultEnvValues[key]);
 }
-exports.getEnvRPC = getEnvRPC;
 function getEnvValue(key, defaultValue) {
     var _a, _b, _c;
     key = key.toUpperCase();
     defaultValue = defaultValue !== null && defaultValue !== void 0 ? defaultValue : defaultEnvValues[key];
     return (_c = (_b = (_a = process.env['LLAMA_SDK_' + key]) !== null && _a !== void 0 ? _a : process.env['SDK_' + key]) !== null && _b !== void 0 ? _b : process.env[key]) !== null && _c !== void 0 ? _c : defaultValue;
 }
-exports.getEnvValue = getEnvValue;
 function getEnvCacheFolder(defaultCacheFolder) {
     return getEnvValue('TVL_LOCAL_CACHE_ROOT_FOLDER', defaultCacheFolder);
 }
-exports.getEnvCacheFolder = getEnvCacheFolder;
 function getEnvMulticallAddress(chain) {
     return getEnvValue(`${chain}_RPC_MULTICALL`);
 }
-exports.getEnvMulticallAddress = getEnvMulticallAddress;
 function getDefaultChunkSize(chain) {
     const key = chain + '_MULTICALL_CHUNK_SIZE';
     if (getEnvValue(key))
@@ -86,7 +97,6 @@ function getDefaultChunkSize(chain) {
         return 50;
     return +(getEnvValue('MULTICALL_CHUNK_SIZE', '300'));
 }
-exports.getDefaultChunkSize = getDefaultChunkSize;
 function getBatchMaxCount(chain) {
     const key = chain + '_BATCH_MAX_COUNT';
     if (getEnvValue(key))
@@ -96,14 +106,12 @@ function getBatchMaxCount(chain) {
         default: return +getEnvValue('BATCH_MAX_COUNT', '5');
     }
 }
-exports.getBatchMaxCount = getBatchMaxCount;
 function getArchivalRPCs(chain) {
     const key = chain + '_ARCHIVAL_RPC';
     if (getEnvValue(key))
         return getEnvValue(key).split(',');
     return [];
 }
-exports.getArchivalRPCs = getArchivalRPCs;
 function getChainRPCs(chain, defaultList = []) {
     const envValue = getEnvRPC(chain);
     if (defaultList.length) {
@@ -114,4 +122,9 @@ function getChainRPCs(chain, defaultList = []) {
     }
     return envValue || undefined;
 }
-exports.getChainRPCs = getChainRPCs;
+function getWhitelistedRPCs(chain) {
+    const key = chain + '_WHITELISTED_RPC';
+    if (getEnvValue(key))
+        return getEnvValue(key).split(',');
+    return [];
+}

package/build/util/graph.js

@@ -1,10 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.modifyEndpoint = exports.request = void 0;
-const axios_1 = __importDefault(require("axios"));
+exports.request = request;
+exports.modifyEndpoint = modifyEndpoint;
+const common_1 = require("./common");
 const cache_1 = require("./cache");
 const debugLog_1 = require("./debugLog");
 const env_1 = require("./env");
@@ -27,13 +25,12 @@ async function request(endpoint, query, { cache = false, cacheKey, variables, wi
     }
     async function _request() {
         endpoint = modifyEndpoint(endpoint, network);
-        const { data: result } = await axios_1.default.post(endpoint, { query, variables });
+        const result = await (0, common_1.postJson)(endpoint, { query, variables });
         if (result.errors)
             throw new Error(result.errors[0].message);
         return withMetadata ? result : result.data;
     }
 }
-exports.request = request;
 let graphKeyWarned = false;
 function modifyEndpoint(endpoint, network = 'arbitrum') {
     // example: https://api.thegraph.com/subgraphs/name/yieldyak/reinvest-tracker
@@ -51,4 +48,3 @@ function modifyEndpoint(endpoint, network = 'arbitrum') {
     endpoint = endpoint.replace('[api-key]', graphKey);
     return endpoint;
 }
-exports.modifyEndpoint = modifyEndpoint;

package/build/util/index.d.ts

@@ -3,7 +3,7 @@ import type { Address } from "../types";
 import { ethers, EventLog } from "ethers";
 import runInPromisePoolOrig from "./promisePool";
 export { getLatestBlock, getTimestamp, lookupBlock, } from "./blocks";
-export { convertToBigInt } from "../generalUtil";
+export { convertToBigInt } from "./common";
 export declare const runInPromisePool: typeof runInPromisePoolOrig;
 export declare function sliceIntoChunks(arr: any[], chunkSize?: number): any[][];
 type GetLogsOptions = {

package/build/util/index.js

@@ -3,18 +3,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tableToString = exports.normalizeBalances = exports.normalizePrefixes = exports.normalizeAddress = exports.getLogs = exports.sliceIntoChunks = exports.runInPromisePool = exports.convertToBigInt = exports.lookupBlock = exports.getTimestamp = exports.getLatestBlock = void 0;
+exports.runInPromisePool = exports.convertToBigInt = exports.lookupBlock = exports.getTimestamp = exports.getLatestBlock = void 0;
+exports.sliceIntoChunks = sliceIntoChunks;
+exports.getLogs = getLogs;
+exports.normalizeAddress = normalizeAddress;
+exports.normalizePrefixes = normalizePrefixes;
+exports.normalizeBalances = normalizeBalances;
+exports.tableToString = tableToString;
 const general_1 = require("../general");
 const ethers_1 = require("ethers");
-const generalUtil_1 = require("../generalUtil");
+const common_1 = require("./common");
 const debugLog_1 = require("./debugLog");
 const promisePool_1 = __importDefault(require("./promisePool"));
 var blocks_1 = require("./blocks");
 Object.defineProperty(exports, "getLatestBlock", { enumerable: true, get: function () { return blocks_1.getLatestBlock; } });
 Object.defineProperty(exports, "getTimestamp", { enumerable: true, get: function () { return blocks_1.getTimestamp; } });
 Object.defineProperty(exports, "lookupBlock", { enumerable: true, get: function () { return blocks_1.lookupBlock; } });
-var generalUtil_2 = require("../generalUtil");
-Object.defineProperty(exports, "convertToBigInt", { enumerable: true, get: function () { return generalUtil_2.convertToBigInt; } });
+var common_2 = require("./common");
+Object.defineProperty(exports, "convertToBigInt", { enumerable: true, get: function () { return common_2.convertToBigInt; } });
 const p_limit_1 = __importDefault(require("p-limit"));
 const env_1 = require("./env");
 exports.runInPromisePool = promisePool_1.default;
@@ -26,7 +32,6 @@ function sliceIntoChunks(arr, chunkSize = 100) {
     }
     return res;
 }
-exports.sliceIntoChunks = sliceIntoChunks;
 const chainLogLimiters = {};
 function getChainLimiter(chain, providerUrl) {
     if (!chainLogLimiters[chain])
@@ -37,7 +42,7 @@ function getChainLimiter(chain, providerUrl) {
     }
 }
 async function getLogs(options) {
-    const getLimiter = () => getChainLimiter(options.chain, (0, generalUtil_1.getProviderUrl)(options.provider));
+    const getLimiter = () => getChainLimiter(options.chain, (0, common_1.getProviderUrl)(options.provider));
     // if provider is not passed, we try with archival node first (if set) and then with non-archival node
     let provider;
     if (!options.provider) {
@@ -50,13 +55,13 @@ async function getLogs(options) {
         catch (e) {
             options.provider = (0, general_1.getProvider)(options.chain, false);
             // if (provider === options.provider) throw e // the provider for archival and non-archival request is the same
-            (0, debugLog_1.debugLog)(`Error fetching logs for chain ${options.chain} ${(0, generalUtil_1.formError)(e, { chain: options.chain, target: options.target, })}, retrying...`);
+            if (env_1.logGetLogsDebug)
+                (0, debugLog_1.debugLog)(`Error fetching logs for chain ${options.chain} ${(0, common_1.formError)(e, { chain: options.chain, target: options.target, })}, retrying...`);
             return getLimiter()(() => _getLogs(options));
         }
     }
     return getLimiter()(() => _getLogs(options));
 }
-exports.getLogs = getLogs;
 // SMALL INCOMPATIBILITY: On the old API we don't return ids but we should
 async function _getLogs(params) {
     var _a, _b;
@@ -86,7 +91,8 @@ async function _getLogs(params) {
             currentBlock = nextBlock;
         }
         catch (e) {
-            (0, debugLog_1.debugLog)(`Error fetching logs for chain ${params.chain} blockSpread: ${blockSpread}. ${(0, generalUtil_1.formError)(e, { chain: params.chain, target: params.target, provider })}`);
+            if (env_1.logGetLogsDebug)
+                (0, debugLog_1.debugLog)(`Error fetching logs for chain ${params.chain} blockSpread: ${blockSpread}. ${(0, common_1.formError)(e, { chain: params.chain, target: params.target, provider })}`);
             if (blockSpread >= 1001) {
                 // We got too many results
                 // We could chop it up into 1001 block spreads as that is guaranteed to always return but then we'll have to make a lot of queries (easily >1000), so instead we'll keep dividing the block spread by two until we make it
@@ -97,7 +103,7 @@ async function _getLogs(params) {
                     blockSpread = 9999;
             }
             else {
-                const error = (0, generalUtil_1.formError)(e, { chain: params.chain, target: params.target, provider });
+                const error = (0, common_1.formError)(e, { chain: params.chain, target: params.target, provider });
                 error.message = `[chain: ${params.chain}] ${error === null || error === void 0 ? void 0 : error.message} params: ${JSON.stringify(logParams)}`;
                 throw e;
             }
@@ -127,7 +133,6 @@ function normalizeAddress(address) {
         return address;
     return address.toLowerCase();
 }
-exports.normalizeAddress = normalizeAddress;
 function normalizePrefixes(address) {
     const prefix = address.substring(0, address.indexOf(":"));
     if (["solana", "tezos"].includes(prefix))
@@ -138,7 +143,6 @@ function normalizePrefixes(address) {
             ? `coingecko:${address.toLowerCase()}`
             : address.toLowerCase();
 }
-exports.normalizePrefixes = normalizePrefixes;
 const ethereumAddress = "ethereum:0x0000000000000000000000000000000000000000";
 const weth = "ethereum:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
 function normalizeBalances(balances) {
@@ -151,7 +155,7 @@ function normalizeBalances(balances) {
         const normalisedKey = normalizePrefixes(key);
         if (normalisedKey == key)
             return;
-        (0, generalUtil_1.sumSingleBalance)(balances, normalisedKey, balances[key]);
+        (0, common_1.sumSingleBalance)(balances, normalisedKey, balances[key]);
         delete balances[key];
     });
     const eth = balances[ethereumAddress];
@@ -161,7 +165,6 @@ function normalizeBalances(balances) {
     }
     return balances;
 }
-exports.normalizeBalances = normalizeBalances;
 function tableToString(data, columns, { title, columns: _columns } = {}) {
     // If only two arguments are passed and the second is not an array, treat it as options
     if (arguments.length === 2 && !Array.isArray(columns) && typeof columns === 'object') {
@@ -222,4 +225,3 @@ function tableToString(data, columns, { title, columns: _columns } = {}) {
     });
     return tableString;
 }
-exports.tableToString = tableToString;

package/build/util/indexer.js

@@ -3,11 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIndexer2Enabled = exports.isIndexerEnabled = exports.getTransactions = exports.getTokenTransfers = exports.getLogs = exports.getTokens = exports.supportedChainSet2 = exports.supportedChainSet = void 0;
+exports.supportedChainSet2 = exports.supportedChainSet = void 0;
+exports.getTokens = getTokens;
+exports.getLogs = getLogs;
+exports.getTokenTransfers = getTokenTransfers;
+exports.getTransactions = getTransactions;
+exports.isIndexerEnabled = isIndexerEnabled;
+exports.isIndexer2Enabled = isIndexer2Enabled;
 const axios_1 = __importDefault(require("axios"));
 const _1 = require(".");
 const general_1 = require("../general");
-const generalUtil_1 = require("../generalUtil");
+const common_1 = require("./common");
 const blocks_1 = require("./blocks");
 const cache_1 = require("./cache");
 const debugLog_1 = require("./debugLog");
@@ -104,7 +110,7 @@ async function getChainIndexStatus(version = "v2") {
         return state.chainIndexStatus;
     state.timestamp = Date.now();
     state.chainIndexStatus = (async () => {
-        const { data: { syncStatus }, } = await axiosInstances[version].get(`/sync`);
+        const { data: { syncStatus }, } = await axiosInstances[version].get(`/sync`).catch(e => { throw (0, common_1.formError)(e); });
         const info = {};
         syncStatus.forEach((d) => {
             const chain = indexerConfigs[version].chainMapping[d.chain];
@@ -154,7 +160,8 @@ async function getTokens(address, { onlyWhitelisted = true, skipCacheRead = fals
         if (cache.timestamp && timeNow - cache.timestamp < THREE_DAYS)
             return cache.tokens;
     }
-    (0, debugLog_1.debugLog)("[Indexer] Pulling tokens for " + address);
+    if (env_1.logGetLogsIndexer)
+        (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`, {
         params: {
@@ -162,7 +169,7 @@ async function getTokens(address, { onlyWhitelisted = true, skipCacheRead = fals
             chainId,
             type: tokenType,
         },
-    });
+    }).catch(e => { throw (0, common_1.formError)(e); });
     balances
         .filter((b) => +b.total_amount > 0)
         .forEach((b) => {
@@ -176,13 +183,12 @@ async function getTokens(address, { onlyWhitelisted = true, skipCacheRead = fals
     const tokenCache = { timestamp: timeNow, tokens };
     Object.entries(tokens).forEach(([chain, values]) => {
         values.push(general_1.ETHER_ADDRESS);
-        tokens[chain] = (0, generalUtil_1.getUniqueAddresses)(values);
+        tokens[chain] = (0, common_1.getUniqueAddresses)(values);
     });
     if (!skipCache)
         await (0, cache_1.writeCache)(file, tokenCache);
     return tokens;
 }
-exports.getTokens = getTokens;
 // ---------------------------------------------------------------------------
 // LOGS (v2 only)
 // ---------------------------------------------------------------------------
@@ -191,7 +197,7 @@ async function getLogs(options) {
     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;
+        debugMode = debugLog_1.DEBUG_LEVEL2 && env_1.logGetLogsIndexer;
     const blockRange = toBlock - fromBlock;
     const effectiveMaxBlockRange = maxBlockRange !== null && maxBlockRange !== void 0 ? maxBlockRange : (noTarget ? 10000 : Infinity);
     if (noTarget && blockRange > 500000) {
@@ -204,7 +210,16 @@ async function getLogs(options) {
     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}`);
+        const percentageMissing = ((toBlock - lastIndexedBlock) / (toBlock - fromBlock)) * 100;
+        if (percentageMissing > 50) // more than 50% of the requested range is missing, throw an error and so we pull the logs through rpc calls
+            throw new Error(`Indexer not up to date for ${chain}. Last indexed block: ${lastIndexedBlock}, requested block: ${toBlock}`);
+        if (env_1.logGetLogsIndexer)
+            (0, debugLog_1.debugLog)(`Indexer only partially up to date for ${chain}. Last indexed block: ${lastIndexedBlock}, requested block: ${toBlock}, missing ${Number(percentageMissing).toFixed(2)}%. Pulling part of the logs through RPC calls.`);
+        // now we split the request into two parts, one that goes to the indexer and one that goes through rpc calls
+        const breakBlock = lastIndexedBlock - 50; // we add a small buffer to avoid missing logs due to reorgs
+        const indexerLogs = await getLogs({ ...options, fromBlock, toBlock: breakBlock });
+        const rpcLogs = await (0, logs_1.getLogs)({ ...options, fromBlock: breakBlock + 1, toBlock, skipIndexer: true });
+        return indexerLogs.concat(rpcLogs);
     }
     // Re‑curse if the requested range is too large ------------------------------------------------
     if (blockRange > effectiveMaxBlockRange) {
@@ -265,7 +280,7 @@ async function getLogs(options) {
                 parseLog: options.parseLog,
                 onlyArgs: options.onlyArgs,
             };
-            const { data: { logs: _logs, totalCount }, } = await axiosInstances.v2(`/logs`, { params });
+            const { data: { logs: _logs, totalCount }, } = await axiosInstances.v2(`/logs`, { params }).catch(e => { throw (0, common_1.formError)(e); });
             const filtered = _logs.filter((l) => {
                 const isWhitelisted = !addressSet.size || addressSet.has(l.source.toLowerCase());
                 if (!isWhitelisted)
@@ -308,14 +323,13 @@ async function getLogs(options) {
     }
     return allLogs.map(i => i.transformed);
 }
-exports.getLogs = getLogs;
 // ---------------------------------------------------------------------------
 // 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;
+        debugMode = debugLog_1.DEBUG_LEVEL2 && env_1.logGetLogsIndexer;
     checkIndexerConfig("v2");
     const chainId = getChainId(chain, "v2");
     // -----------------------------------------------------------------------
@@ -393,7 +407,7 @@ async function getTokenTransfers({ chain = "ethereum", fromAddressFilter, fromBl
             default:
                 throw new Error("Invalid transferType");
         }
-        const { data: { transfers: _logs, totalCount }, } = await axiosInstances.v2(`/token-transfers`, { params });
+        const { data: { transfers: _logs, totalCount }, } = await axiosInstances.v2(`/token-transfers`, { params }).catch(e => { throw (0, common_1.formError)(e); });
         rawTransfers.push(..._logs);
         currentOffset += limit;
         if (_logs.length < limit || totalCount <= rawTransfers.length || _logs.length === 0)
@@ -426,14 +440,13 @@ async function getTokenTransfers({ chain = "ethereum", fromAddressFilter, fromBl
     }
     return filteredTransfers;
 }
-exports.getTokenTransfers = getTokenTransfers;
 // ---------------------------------------------------------------------------
 // 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;
+        debugMode = debugLog_1.DEBUG_LEVEL2 && env_1.logGetLogsIndexer;
     checkIndexerConfig("v2");
     const chainId = getChainId(chain, "v2");
     if ((!addresses || addresses.length === 0) && (!transaction_hashes || transaction_hashes.length === 0))
@@ -471,7 +484,7 @@ async function getTransactions({ chain = "ethereum", addresses, transaction_hash
         (0, debugLog_1.debugLog)("[Indexer] Pulling transactions " + debugTimeKey);
         console.time(debugTimeKey);
     }
-    const { data: { transactions } } = await axiosInstances.v2(`/transactions`, { params });
+    const { data: { transactions } } = await axiosInstances.v2(`/transactions`, { params }).catch(e => { throw (0, common_1.formError)(e); });
     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);
@@ -502,7 +515,6 @@ async function getTransactions({ chain = "ethereum", addresses, transaction_hash
         timestamp: t.timestamp,
     }));
 }
-exports.getTransactions = getTransactions;
 // ---------------------------------------------------------------------------
 // Public helpers
 // ---------------------------------------------------------------------------
@@ -514,9 +526,7 @@ function isIndexerEnabled(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;

package/build/util/internal-cache.js

@@ -15,15 +15,29 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.retriveCache = exports.startCache = exports.saveCache = exports.setCache = exports.getCache = void 0;
+exports.getCache = getCache;
+exports.setCache = setCache;
+exports.saveCache = saveCache;
+exports.startCache = startCache;
+exports.retriveCache = retriveCache;
 const fs = __importStar(require("fs"));
 const env_1 = require("./env");
 // const cacheFile = __dirname + '/../../../sc-cache1.json'
@@ -41,7 +55,6 @@ function getCache(options) {
         cache[chain][abi] = {};
     return cache[chain][abi][address];
 }
-exports.getCache = getCache;
 function setCache(options) {
     let { address, abi, chain = "ethereum", value } = options;
     if (!address)
@@ -53,16 +66,12 @@ function setCache(options) {
         cache[chain][abi] = {};
     cache[chain][abi][address] = value;
 }
-exports.setCache = setCache;
 function saveCache() {
     fs.writeFileSync(cacheFile || './cache.json', JSON.stringify(cache));
 }
-exports.saveCache = saveCache;
 function startCache(_cache = {}) {
     cache = _cache;
 }
-exports.startCache = startCache;
 function retriveCache() {
     return cache;
 }
-exports.retriveCache = retriveCache;

package/build/util/logs.js

@@ -3,15 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLogParams = exports.toFilterTopic = exports.getLogs = void 0;
+exports.getLogs = getLogs;
+exports.toFilterTopic = toFilterTopic;
+exports.getLogParams = getLogParams;
 const ethers_1 = require("ethers");
 const _1 = require(".");
-const tron_1 = require("../abi/tron");
 const blocks_1 = require("./blocks");
 const cache_1 = require("./cache");
 const debugLog_1 = require("./debugLog");
 const indexer_1 = require("./indexer");
 const promisePool_1 = __importDefault(require("./promisePool"));
+const env_1 = require("./env");
+const common_1 = require("./common");
 const currentVersion = "v3";
 /* -------------------------------------------------------------------------- */
 /*                                   getLogs                                  */
@@ -43,7 +46,7 @@ async function getLogs(options) {
         }
     }
     if (!debugMode)
-        debugMode = debugLog_1.DEBUG_LEVEL2;
+        debugMode = debugLog_1.DEBUG_LEVEL2 && env_1.logGetLogsDebug;
     /* ----------------------- Split by maxBlockRange ------------------------- */
     const blockRange = toBlock - fromBlock;
     if (maxBlockRange && blockRange > maxBlockRange) {
@@ -76,7 +79,7 @@ async function getLogs(options) {
     }
     /* ----------------------------- RPC fallback ----------------------------- */
     if (chain === "tron")
-        target = (0, tron_1.hexifyTarget)(target);
+        target = (0, common_1.tronToEvmAddress)(target);
     let caches = (await _getCache());
     const firstRun = !caches.length;
     if (firstRun || skipCacheRead) {
@@ -203,7 +206,6 @@ async function getLogs(options) {
         return `event-logs/${chain}/${(_a = target === null || target === void 0 ? void 0 : target.toLowerCase()) !== null && _a !== void 0 ? _a : null}-${extraKey}`;
     }
 }
-exports.getLogs = getLogs;
 /* -------------------------------------------------------------------------- */
 /*                           Utility helpers exported                         */
 /* -------------------------------------------------------------------------- */
@@ -213,7 +215,6 @@ function toFilterTopic(topic) {
     const fragment = ethers_1.EventFragment.from(topic);
     return (0, ethers_1.id)(fragment.format());
 }
-exports.toFilterTopic = toFilterTopic;
 exports.default = getLogs;
 async function getLogParams(options, isIndexerCall = false) {
     let { target, chain = "ethereum", fromBlock, toBlock, fromTimestamp, toTimestamp, eventAbi, topic, topics, extraTopics, entireLog = false, onlyArgs = false, targets = [], noTarget = false, parseLog = false, allowParseFailure = false, processor, flatten = false, } = options;
@@ -331,4 +332,3 @@ async function getLogParams(options, isIndexerCall = false) {
         topics,
     };
 }
-exports.getLogParams = getLogParams;

package/build/util/promisePool.d.ts

@@ -2,4 +2,7 @@ export default function runInPromisePool(params: {
     items: any[];
     concurrency: number;
     processor: any;
-}): Promise<any[]>;
+    permitFailure?: boolean;
+    withMetadata?: boolean;
+}): Promise<any>;
+export { runInPromisePool };

package/build/util/promisePool.js

@@ -1,16 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = runInPromisePool;
+exports.runInPromisePool = runInPromisePool;
 const promise_pool_1 = require("@supercharge/promise-pool");
-const generalUtil_1 = require("../generalUtil");
-generalUtil_1.formError;
+const common_1 = require("./common");
 async function runInPromisePool(params) {
-    const { results, errors } = await promise_pool_1.PromisePool
+    const errors = [];
+    const { results, } = await promise_pool_1.PromisePool
         .withConcurrency(params.concurrency)
         .for(params.items)
-        .process(async (item, i) => [await params.processor(item, i), i]);
-    if (errors.length)
-        throw (0, generalUtil_1.formError)(null, { promisePoolErrors: errors });
+        .process(async (item, i) => {
+        try {
+            if (errors.length && !params.permitFailure)
+                throw new Error('Aborting, previous errors in promise pool');
+            const res = await params.processor(item, i);
+            return [res, i];
+        }
+        catch (e) {
+            errors.push(e);
+            return [undefined, i];
+        }
+    });
+    if (errors.length && !params.permitFailure)
+        throw (0, common_1.formError)(null, { promisePoolErrors: errors });
+    // Preserve order of results
     const flatResults = results.sort((a, b) => a[1] - b[1]).map((i => i[0]));
+    if (params.withMetadata)
+        return { results: flatResults, errors };
     return flatResults;
 }
-exports.default = runInPromisePool;

package/build/util/r2.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="node" />
 export declare function storeR2JSONString(filename: string, body: string | Buffer): Promise<any>;
 export declare function getR2JSONString(filename: string): Promise<any>;

package/build/util/r2.js

@@ -1,11 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getR2JSONString = exports.storeR2JSONString = void 0;
-const axios_1 = __importDefault(require("axios"));
+exports.storeR2JSONString = storeR2JSONString;
+exports.getR2JSONString = getR2JSONString;
 const env_1 = require("./env");
+const common_1 = require("./common");
 const { S3Client, PutObjectCommand, GetObjectCommand, } = require("@aws-sdk/client-s3");
 const { R2_ENDPOINT, R2_ACCESS_KEY_ID, R2_SECRET_ACCESS_KEY } = env_1.ENV_CONSTANTS;
 const datasetBucket = "defillama-datasets";
@@ -35,7 +33,6 @@ async function storeR2JSONString(filename, body) {
     });
     return R2.send(command);
 }
-exports.storeR2JSONString = storeR2JSONString;
 async function getR2JSONString(filename) {
     try {
         if (!R2)
@@ -48,8 +45,6 @@ async function getR2JSONString(filename) {
         return {};
     }
     async function _fetchData() {
-        const response = await (0, axios_1.default)(`${publicBucketUrl}/${filename}`);
-        return response.data;
+        return (0, common_1.fetchJson)(`${publicBucketUrl}/${filename}`);
     }
 }
-exports.getR2JSONString = getR2JSONString;