@defillama/sdk 5.0.10 → 5.0.12

package/build/util/computeTVL.js

@@ -1,166 +1,88 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUnique = void 0;
-var _1 = require(".");
-var generalUtil_1 = require("../generalUtil");
-var node_fetch_1 = __importDefault(require("node-fetch"));
-var currentPriceCache = {};
-var priceCaches = {};
-var lastPriceUpdate = 0;
-var confidenceThreshold = 0.5;
-var priceUpdateTime = 1000 * 60 * 30; // 30 minutes
-function computeTVL(balances, timestamp) {
-    return __awaiter(this, void 0, void 0, function () {
-        var usdTokenBalances, usdTvl, keys, priceCache;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    usdTokenBalances = {};
-                    usdTvl = 0;
-                    keys = Object.keys(balances).filter(function (i) { return +balances[i] > 0; }).map(tokenToKey);
-                    return [4 /*yield*/, updatePriceCache(keys, timestamp)];
-                case 1:
-                    _a.sent();
-                    priceCache = getPriceCache(timestamp);
-                    Object.entries(balances).forEach(function (_a) {
-                        var _b;
-                        var token = _a[0], balance = _a[1];
-                        if (+balance <= 0)
-                            return;
-                        var key = tokenToKey(token).toLowerCase();
-                        var _c = (_b = priceCache[key]) !== null && _b !== void 0 ? _b : {}, price = _c.price, confidence = _c.confidence, _d = _c.decimals, decimals = _d === void 0 ? 0 : _d, _e = _c.symbol, symbol = _e === void 0 ? token : _e;
-                        if (!price || confidence < confidenceThreshold)
-                            return;
-                        var value = +balance * price / (Math.pow(10, decimals));
-                        usdTvl += value;
-                        if (symbol === 'ETH')
-                            symbol = 'WETH';
-                        (0, generalUtil_1.sumSingleBalance)(usdTokenBalances, symbol, value);
-                    });
-                    return [2 /*return*/, { usdTvl: usdTvl, usdTokenBalances: usdTokenBalances }];
-            }
-        });
+const _1 = require(".");
+const generalUtil_1 = require("../generalUtil");
+const axios_1 = __importDefault(require("axios"));
+const env_1 = require("./env");
+const currentPriceCache = {};
+const priceCaches = {};
+let lastPriceUpdate = 0;
+const confidenceThreshold = 0.5;
+const priceUpdateTime = 1000 * 60 * 30; // 30 minutes
+async function computeTVL(balances, timestamp) {
+    const usdTokenBalances = {};
+    let usdTvl = 0;
+    const keys = Object.keys(balances).filter(i => +balances[i] > 0).map(tokenToKey);
+    await updatePriceCache(keys, timestamp);
+    const priceCache = getPriceCache(timestamp);
+    Object.entries(balances).forEach(([token, balance]) => {
+        var _a;
+        if (+balance <= 0)
+            return;
+        const key = tokenToKey(token).toLowerCase();
+        let { price, confidence, decimals = 0, symbol = token } = (_a = priceCache[key]) !== null && _a !== void 0 ? _a : {};
+        if (!price || confidence < confidenceThreshold)
+            return;
+        const value = +balance * price / (10 ** decimals);
+        usdTvl += value;
+        if (symbol === 'ETH')
+            symbol = 'WETH';
+        (0, generalUtil_1.sumSingleBalance)(usdTokenBalances, symbol, value);
     });
+    return { usdTvl, usdTokenBalances };
 }
 exports.default = computeTVL;
 function tokenToKey(token) {
     if (token.startsWith("0x"))
-        token = "ethereum:".concat(token);
+        token = `ethereum:${token}`;
     else if (!token.includes(':'))
-        token = "coingecko:".concat(token);
+        token = `coingecko:${token}`;
     return token;
 }
-function updatePriceCache(keys, timestamp) {
-    return __awaiter(this, void 0, void 0, function () {
-        function getPrices(keys) {
-            return __awaiter(this, void 0, void 0, function () {
-                var coins_1, coins;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            if (!!timestamp) return [3 /*break*/, 2];
-                            return [4 /*yield*/, (0, node_fetch_1.default)("https://coins.llama.fi/prices/current/".concat(keys.join(','))).then(function (res) { return res.json(); })];
-                        case 1:
-                            coins_1 = (_a.sent()).coins;
-                            return [2 /*return*/, coins_1];
-                        case 2: return [4 /*yield*/, (0, node_fetch_1.default)("https://coins.llama.fi/prices?source=internal", {
-                                method: 'POST',
-                                body: JSON.stringify({ coins: keys, timestamp: timestamp }),
-                                headers: { "Content-Type": "application/json" },
-                            }).then(function (res) { return res.json(); })];
-                        case 3:
-                            coins = (_a.sent()).coins;
-                            return [2 /*return*/, coins];
-                    }
-                });
-            });
+async function updatePriceCache(keys, timestamp) {
+    if (isNearlyNow(timestamp))
+        timestamp = undefined;
+    keys = getUnique(keys);
+    const pricesCache = getPriceCache(timestamp);
+    if (!timestamp && lastPriceUpdate && +Date.now() > lastPriceUpdate + priceUpdateTime) {
+        lastPriceUpdate = +Date.now();
+        Object.keys(pricesCache).forEach(key => delete pricesCache[key]); // clear cache   
+    }
+    // hardcode cache for USDT
+    pricesCache['coingecko:tether'] = {
+        "price": 1,
+        "symbol": "USDT",
+        "confidence": 1
+    };
+    pricesCache['ethereum:0xdac17f958d2ee523a2206206994597c13d831ec7'] = {
+        "price": 1,
+        "symbol": "USDT",
+        "decimals": 6,
+        "confidence": 1
+    };
+    const missingKeys = keys.filter(key => !pricesCache[key.toLowerCase()]);
+    const chunks = (0, _1.sliceIntoChunks)(missingKeys, 100);
+    for (const chunk of chunks) {
+        const coins = await getPrices(chunk);
+        for (const [token, data] of Object.entries(coins)) {
+            pricesCache[token.toLowerCase()] = data;
         }
-        var pricesCache, missingKeys, chunks, _i, chunks_1, chunk, coins, _a, _b, _c, token, data;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    if (isNearlyNow(timestamp))
-                        timestamp = undefined;
-                    keys = getUnique(keys);
-                    pricesCache = getPriceCache(timestamp);
-                    if (!timestamp && lastPriceUpdate && +Date.now() > lastPriceUpdate + priceUpdateTime) {
-                        lastPriceUpdate = +Date.now();
-                        Object.keys(pricesCache).forEach(function (key) { return delete pricesCache[key]; }); // clear cache   
-                    }
-                    // hardcode cache for USDT
-                    pricesCache['coingecko:tether'] = {
-                        "price": 1,
-                        "symbol": "USDT",
-                        "confidence": 1
-                    };
-                    pricesCache['ethereum:0xdac17f958d2ee523a2206206994597c13d831ec7'] = {
-                        "price": 1,
-                        "symbol": "USDT",
-                        "decimals": 6,
-                        "confidence": 1
-                    };
-                    missingKeys = keys.filter(function (key) { return !pricesCache[key.toLowerCase()]; });
-                    chunks = (0, _1.sliceIntoChunks)(missingKeys, 100);
-                    _i = 0, chunks_1 = chunks;
-                    _d.label = 1;
-                case 1:
-                    if (!(_i < chunks_1.length)) return [3 /*break*/, 4];
-                    chunk = chunks_1[_i];
-                    return [4 /*yield*/, getPrices(chunk)];
-                case 2:
-                    coins = _d.sent();
-                    for (_a = 0, _b = Object.entries(coins); _a < _b.length; _a++) {
-                        _c = _b[_a], token = _c[0], data = _c[1];
-                        pricesCache[token.toLowerCase()] = data;
-                    }
-                    chunk.map(function (i) { return i.toLowerCase(); }).filter(function (i) { return !pricesCache[i]; }).forEach(function (i) { return pricesCache[i] = {}; });
-                    _d.label = 3;
-                case 3:
-                    _i++;
-                    return [3 /*break*/, 1];
-                case 4: return [2 /*return*/];
-            }
-        });
-    });
+        chunk.map(i => i.toLowerCase()).filter(i => !pricesCache[i]).forEach(i => pricesCache[i] = {});
+    }
+    async function getPrices(keys) {
+        if (!timestamp) {
+            const { coins } = await axios_1.default.get(`https://coins.llama.fi/prices/current/${keys.join(',')}`).then((res) => res.data);
+            return coins;
+        }
+        // fetch post with timestamp in body
+        const coinsApiKey = env_1.ENV_CONSTANTS['COINS_API_KEY'];
+        const { coins } = await axios_1.default.post("https://coins.llama.fi/prices?source=internal&apikey=" + coinsApiKey, { coins: keys, timestamp }).then((res) => res.data);
+        return coins;
+    }
 }
 function getPriceCache(timestamp) {
     if (timestamp)
@@ -170,8 +92,8 @@ function getPriceCache(timestamp) {
     return timestamp ? priceCaches[timestamp] : currentPriceCache;
 }
 function getUnique(addresses) {
-    var set = {};
-    addresses.forEach(function (i) { return set[i] = true; });
+    const set = {};
+    addresses.forEach(i => set[i] = true);
     return Object.keys(set);
 }
 exports.getUnique = getUnique;

package/build/util/cosmos.js

@@ -1,52 +1,16 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCosmosProvider = exports.getCosmosBlock = exports.isCosmosChain = void 0;
-var node_fetch_1 = __importDefault(require("node-fetch"));
-var env_1 = require("./env");
+const axios_1 = __importDefault(require("axios"));
+const env_1 = require("./env");
 // where to find chain info
 // https://proxy.atomscan.com/chains.json
 // https://cosmos-chain.directory/chains/cosmoshub
 // https://cosmos-chain.directory/chains
-var endPoints = {
+const endPoints = {
     crescent: "https://mainnet.crescent.network:1317",
     osmosis: "https://osmosis-api.polkachu.com",
     cosmos: "https://cosmoshub-lcd.stakely.io",
@@ -78,48 +42,30 @@ var endPoints = {
     nolus: "https://pirin-cl.nolus.network:1317",
     bostrom: "https://lcd.bostrom.cybernode.ai"
 };
-var ibcChains = ['terra', 'terra2', 'crescent', 'osmosis', 'kujira', 'stargaze', 'juno', 'injective', 'cosmos', 'comdex', 'umee', 'orai', 'persistence', 'fxcore', 'neutron', 'quasar', 'chihuahua', 'sei', 'archway', 'migaloo', 'secret', 'aura', 'xpla', 'bostrom'];
-var isCosmosChain = function (chain) { return ibcChains.includes(chain) || !!endPoints[chain]; };
+const ibcChains = ['terra', 'terra2', 'crescent', 'osmosis', 'kujira', 'stargaze', 'juno', 'injective', 'cosmos', 'comdex', 'umee', 'orai', 'persistence', 'fxcore', 'neutron', 'quasar', 'chihuahua', 'sei', 'archway', 'migaloo', 'secret', 'aura', 'xpla', 'bostrom'];
+const isCosmosChain = (chain) => ibcChains.includes(chain) || !!endPoints[chain];
 exports.isCosmosChain = isCosmosChain;
-function getCosmosBlock(block, chain) {
+async function getCosmosBlock(block = 'latest', chain = 'cosmos') {
     var _a;
-    if (block === void 0) { block = 'latest'; }
-    if (chain === void 0) { chain = 'cosmos'; }
-    return __awaiter(this, void 0, void 0, function () {
-        var endPoint, data, _b, height, time, e_1, message;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    endPoint = (0, env_1.getEnvRPC)(chain) || endPoints[chain] || 'https://rest.cosmos.directory/' + chain;
-                    _c.label = 1;
-                case 1:
-                    _c.trys.push([1, 4, , 5]);
-                    return [4 /*yield*/, (0, node_fetch_1.default)("".concat(endPoint, "/blocks/").concat(block))];
-                case 2:
-                    data = _c.sent();
-                    return [4 /*yield*/, data.json()];
-                case 3:
-                    _b = (_c.sent()).block.header, height = _b.height, time = _b.time;
-                    return [2 /*return*/, {
-                            number: Number(height),
-                            timestamp: Math.floor(Date.parse(time) / 1000),
-                        }];
-                case 4:
-                    e_1 = _c.sent();
-                    message = "Error fetchin cosmos block -\n       chain: ".concat(chain, ", block: ").concat(block, ", endPoint: ").concat(endPoint, ", error: ").concat((_a = e_1 === null || e_1 === void 0 ? void 0 : e_1.message) !== null && _a !== void 0 ? _a : JSON.stringify(e_1));
-                    throw new Error(message);
-                case 5: return [2 /*return*/];
-            }
-        });
-    });
+    const endPoint = (0, env_1.getEnvRPC)(chain) || endPoints[chain] || 'https://rest.cosmos.directory/' + chain;
+    try {
+        const { data } = await (0, axios_1.default)(`${endPoint}/blocks/${block}`);
+        const { block: { header: { height, time } } } = await data;
+        return {
+            number: Number(height),
+            timestamp: Math.floor(Date.parse(time) / 1000),
+        };
+    }
+    catch (e) {
+        const message = `Error fetchin cosmos block -
+       chain: ${chain}, block: ${block}, endPoint: ${endPoint}, error: ${(_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : JSON.stringify(e)}`;
+        throw new Error(message);
+    }
 }
 exports.getCosmosBlock = getCosmosBlock;
 function getCosmosProvider(chain) {
     return {
-        getBlock: function (block) {
-            if (block === void 0) { block = 'latest'; }
-            return getCosmosBlock(block, chain);
-        }
+        getBlock: (block = 'latest') => getCosmosBlock(block, chain)
     };
 }
 exports.getCosmosProvider = getCosmosProvider;

package/build/util/debugLog.js

@@ -1,25 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.debugTable = exports.debugLog = exports.DEBUG_ENABLED = void 0;
-var env_1 = require("./env");
+const env_1 = require("./env");
 exports.DEBUG_ENABLED = env_1.ENV_CONSTANTS.DEBUG_ENABLED === "true";
-function debugLog() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
+function debugLog(...args) {
     if (!exports.DEBUG_ENABLED)
         return;
-    console.log.apply(console, args);
+    console.log(...args);
 }
 exports.debugLog = debugLog;
-function debugTable() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
+function debugTable(...args) {
     if (!exports.DEBUG_ENABLED)
         return;
-    console.table.apply(console, args);
+    console.table(...args);
 }
 exports.debugTable = debugTable;

package/build/util/env.d.ts

@@ -1,9 +1,10 @@
 export declare const ENV_CONSTANTS: {
     [x: string]: string | undefined;
 };
-export declare function getChainId(chain: string, chainId: number | undefined): number | undefined;
+export declare function getChainId(chain: string, chainId: number): number;
 export declare function getMaxParallelRequests(chain: string): number;
-export declare function getParallelGetLogsLimit(chain: string): number;
+export declare function getParallelGetLogsLimit(chain: string, providerUrl?: string): number;
+export declare function getParallelGetBlocksLimit(chain: string): number;
 export declare function getEnvRPC(chain: string): string | undefined;
 export declare function getEnvValue(key: string, defaultValue?: string): string | undefined;
 export declare function getEnvCacheFolder(defaultCacheFolder: string): string;

package/build/util/env.js

@@ -1,41 +1,29 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getChainRPCs = exports.getArchivalRPCs = exports.getBatchMaxCount = exports.getDefaultChunkSize = exports.getEnvMulticallAddress = exports.getEnvCacheFolder = exports.getEnvValue = exports.getEnvRPC = exports.getParallelGetLogsLimit = exports.getMaxParallelRequests = exports.getChainId = exports.ENV_CONSTANTS = void 0;
-var _ENV_CONSTANTS = {
+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;
+const _ENV_CONSTANTS = {
     DEBUG_ENABLED: getEnvValue('DEBUG') === "true" || process.env.LLAMA_DEBUG_MODE ? 'true' : 'false',
 };
-var whitelistedEnvConstants = [
-    'R2_ENDPOINT', 'R2_ACCESS_KEY_ID', 'R2_SECRET_ACCESS_KEY', 'TRON_PRO_API_KEY',
+const whitelistedEnvConstants = [
+    'R2_ENDPOINT', 'R2_ACCESS_KEY_ID', 'R2_SECRET_ACCESS_KEY', 'TRON_PRO_API_KEY', 'COINS_API_KEY'
 ];
-var defaultEnvValues = {
+const defaultEnvValues = {
     INTERNAL_SDK_CACHE_FILE: './cache.json',
     TRON_RPC_CONCURRENCY_LIMIT: '5',
     TRON_RPC: 'https://api.trongrid.io',
 };
-whitelistedEnvConstants.forEach(function (key) { return _ENV_CONSTANTS[key] = getEnvValue(key); });
-Object.keys(defaultEnvValues).forEach(function (key) { return _ENV_CONSTANTS[key] = getEnvValue(key, defaultEnvValues[key]); });
+whitelistedEnvConstants.forEach(key => _ENV_CONSTANTS[key] = getEnvValue(key));
+Object.keys(defaultEnvValues).forEach(key => _ENV_CONSTANTS[key] = getEnvValue(key, defaultEnvValues[key]));
 // doing this as I am paranoid that that empty object when first declared might be exported before values are set
-exports.ENV_CONSTANTS = __assign({}, _ENV_CONSTANTS);
+exports.ENV_CONSTANTS = { ..._ENV_CONSTANTS };
 function getChainId(chain, chainId) {
     var _a;
-    var value = (_a = getEnvValue("".concat(chain, "_RPC_CHAIN_ID"))) !== null && _a !== void 0 ? _a : chainId;
-    if (value)
-        return +value;
+    const value = (_a = getEnvValue(`${chain}_RPC_CHAIN_ID`)) !== null && _a !== void 0 ? _a : chainId;
+    return +value;
 }
 exports.getChainId = getChainId;
 function getMaxParallelRequests(chain) {
-    var chainKey = "".concat(chain, "_RPC_MAX_PARALLEL");
+    const chainKey = `${chain}_RPC_MAX_PARALLEL`;
     if (getEnvValue(chainKey))
         return +getEnvValue(chainKey);
     if (['harmony', 'avax'].includes(chain))
@@ -43,19 +31,27 @@ function getMaxParallelRequests(chain) {
     return +getEnvValue('MAX_PARALLEL', '100');
 }
 exports.getMaxParallelRequests = getMaxParallelRequests;
-function getParallelGetLogsLimit(chain) {
-    var defaultLimit = chain === 'fantom' ? '10' : '42';
-    return +(getEnvValue("".concat(chain, "_RPC_GET_LOGS_CONCURRENCY_LIMIT"), defaultLimit));
+function getParallelGetLogsLimit(chain, providerUrl) {
+    const defaultLimit = getEnvValue('GET_LOGS_CONCURRENCY_LIMIT', '5');
+    const defaultAlchemyLimit = getEnvValue('ALCHEMY_GET_LOGS_CONCURRENCY_LIMIT', '4');
+    if (providerUrl && providerUrl.includes('alchemy.com'))
+        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) {
-    return getEnvValue("".concat(chain, "_RPC"));
+    return getEnvValue(`${chain}_RPC`);
 }
 exports.getEnvRPC = getEnvRPC;
 function getEnvValue(key, defaultValue) {
     var _a, _b, _c;
     key = key.toUpperCase();
-    return (_c = (_b = (_a = process.env[key]) !== null && _a !== void 0 ? _a : process.env['SDK_' + key]) !== null && _b !== void 0 ? _b : process.env['LLAMA_SDK_' + key]) !== null && _c !== void 0 ? _c : defaultValue;
+    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) {
@@ -63,11 +59,11 @@ function getEnvCacheFolder(defaultCacheFolder) {
 }
 exports.getEnvCacheFolder = getEnvCacheFolder;
 function getEnvMulticallAddress(chain) {
-    return getEnvValue("".concat(chain, "_RPC_MULTICALL"));
+    return getEnvValue(`${chain}_RPC_MULTICALL`);
 }
 exports.getEnvMulticallAddress = getEnvMulticallAddress;
 function getDefaultChunkSize(chain) {
-    var key = chain + '_MULTICALL_CHUNK_SIZE';
+    const key = chain + '_MULTICALL_CHUNK_SIZE';
     if (getEnvValue(key))
         return +getEnvValue(key);
     if (chain === 'cronos')
@@ -76,7 +72,7 @@ function getDefaultChunkSize(chain) {
 }
 exports.getDefaultChunkSize = getDefaultChunkSize;
 function getBatchMaxCount(chain) {
-    var key = chain + '_BATCH_MAX_COUNT';
+    const key = chain + '_BATCH_MAX_COUNT';
     if (getEnvValue(key))
         return +getEnvValue(key);
     switch (chain) {
@@ -87,15 +83,14 @@ function getBatchMaxCount(chain) {
 }
 exports.getBatchMaxCount = getBatchMaxCount;
 function getArchivalRPCs(chain) {
-    var key = chain + '_ARCHIVAL_RPC';
+    const key = chain + '_ARCHIVAL_RPC';
     if (getEnvValue(key))
         return getEnvValue(key).split(',');
     return [];
 }
 exports.getArchivalRPCs = getArchivalRPCs;
-function getChainRPCs(chain, defaultList) {
-    if (defaultList === void 0) { defaultList = []; }
-    var key = chain + '_RPC';
+function getChainRPCs(chain, defaultList = []) {
+    const key = chain + '_RPC';
     if (getEnvValue(key))
         return getEnvValue(key).split(',').concat(defaultList).join(',');
     if (defaultList.length === 0)

package/build/util/index.d.ts

@@ -1,12 +1,12 @@
 import { Chain } from "../general";
 import type { Address } from "../types";
-import { EventLog } from "ethers";
+import { ethers, EventLog } from "ethers";
 import runInPromisePoolOrig from "./promisePool";
 export { getLatestBlock, getTimestamp, lookupBlock, } from "./blocks";
 export { convertToBigInt } from "../generalUtil";
 export declare const runInPromisePool: typeof runInPromisePoolOrig;
 export declare function sliceIntoChunks(arr: any[], chunkSize?: number): any[][];
-export declare function getLogs(params: {
+type GetLogsOptions = {
     target: Address;
     topic: string;
     keys: string[];
@@ -14,7 +14,9 @@ export declare function getLogs(params: {
     toBlock: number;
     topics?: (string | null)[];
     chain?: Chain;
-}): Promise<{
+    provider?: ethers.Provider;
+};
+export declare function getLogs(options: GetLogsOptions): Promise<{
     output: EventLog[];
 }>;
 export declare function normalizeAddress(address: string): string;